Ardalis.SmartEnum

For flag-like behavior, inherit from SmartFlagEnum<TEnum>.

Requirements:

• Values must be powers of two (1, 2, 4, 8, etc.). If they are not, a SmartFlagEnumDoesNotContainPowerOfTwoValuesException is thrown. You can bypass this with [AllowUnsafeFlagEnumValues], but the enum may not behave as expected.
• You can define explicit Combination values (e.g., CardAndCash = 3) which will be returned by FromValue() instead of the individual flags.
• A value of -1 passed to FromValue() returns an IEnumerable containing all values (excluding 0).

Key Methods:

• FromValue(TValue value): Returns an IEnumerable<TEnum> containing all matching flags.
• FromName(string names): Accepts a comma-separated string of names and returns an IEnumerable<TEnum>.
• FromValueToString(TValue value): Returns a comma-separated string of the names of the matching flags.

public class SmartFlagTestEnum : SmartFlagEnum<SmartFlagTestEnum>
{
    public static readonly SmartFlagTestEnum None = new SmartFlagTestEnum(nameof(None), 0);
    public static readonly SmartFlagTestEnum Card = new SmartFlagTestEnum(nameof(Card), 1);
    public static readonly SmartFlagTestEnum Cash = new SmartFlagTestEnum(nameof(Cash), 2);
    public static readonly SmartFlagTestEnum CardAndCash = new SmartFlagTestEnum(nameof(CardAndCash), 3);
    public static readonly SmartFlagTestEnum Bpay = new SmartFlagTestEnum(nameof(Bpay), 4);

    public SmartFlagTestEnum(string name, int value) : base(name, value)
    {
    }
}

// Usage
var result = SmartFlagTestEnum.FromValue(3); // Returns Card and Cash
var names = SmartFlagTestEnum.FromValueToString(3); // "Card, Cash"

Unlike standard enums, SmartEnums can use inheritance to attach properties or methods to specific enum members. This allows you to replace switch statements with polymorphic behavior. You define an abstract base class and private sealed classes for each enum member that override the abstract members.

using Ardalis.SmartEnum;

public abstract class EmployeeType : SmartEnum<EmployeeType>
{
    public static readonly EmployeeType Manager = new ManagerType();
    public static readonly EmployeeType Assistant = new AssistantType();

    private EmployeeType(string name, int value) : base(name, value)
    {
    }

    public abstract decimal BonusSize { get; }

    private sealed class ManagerType : EmployeeType
    {
        public ManagerType() : base("Manager", 1) {}

        public override decimal BonusSize => 10_000m;
    }

    private sealed class AssistantType : EmployeeType
    {
        public AssistantType() : base("Assistant", 2) {}

        public override decimal BonusSize => 1_000m;
    }
}

To persist SmartEnums in EF Core, you must map the enum to its underlying value type using value conversions.

Manual Configuration (EF Core 2.1+)

Use HasConversion in OnModelCreating to map the property to its Value and use FromValue to reconstruct it.

Note: You must implement a parameterless constructor in your SmartEnum class for EF Core to work correctly.

builder.Entity<Policy>()
    .Property(p => p.PolicyStatus)
    .HasConversion(
        p => p.Value,
        p => PolicyStatus.FromValue(p));

Automatic Configuration (using Ardalis.SmartEnum.EFCore)

If you have the Ardalis.SmartEnum.EFCore package installed, you can use pre-convention configuration.

EF Core 6+:

protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.ConfigureSmartEnum();
}

EF Core < 6:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.ConfigureSmartEnum();
}

// EF Core 6+ example
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
    configurationBuilder.ConfigureSmartEnum();
}