如何在EF6 Code First中创建与枚举对应的表？

Question

我已关注MSDN，了解如何在 EF6 的 Code First 中处理枚举。它起作用了，正如预期的那样但是创建的表中引用枚举数的字段是一个简单的int。

我希望生成第二个表，其值将遵循 C# 代码中枚举数的定义。因此，除了在 MSDN 上的示例中仅获取与 Department 对应的表外，我还希望看到由 Faculty 中的项目填充的第二个表。 p>

public enum Faculty { Eng, Math, Eco }     

public partial class Department 
{ 
  [Key] public Guid ID { get; set; } 
  [Required] public Faculty Name { get; set; } 
}

在研究这个问题时，我偶然发现了一个solution，它建议为枚举创建一个表并通过播种显式填充它。

在我看来，这是一种繁琐的方法，而且很多工作都应该自动处理。毕竟，系统知道构成枚举的实际值。从 DB 的角度来看，它仍然是数据行，就像我创建的实体一样，但从 OO 方面来看，它并不是真正的数据——而是一种类型（松散地表达），可以假设有限且预先知道的状态数量。

是否推荐“手动”填充表格的方法？

Answer 1

由于 EF 不会自动处理，是的，这是推荐的方式。

我建议对您提供的文章进行一些修改。

重命名你的枚举

public enum FacultyEnum { Eng, Math, Eco }

创建一个代表表格的类

public class Faculty
{
    private Faculty(FacultyEnum @enum)
    {
        Id = (int)@enum;
        Name = @enum.ToString();
        Description = @enum.GetEnumDescription();
    }

    protected Faculty() { } //For EF

    [Key, DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; }

    [Required, MaxLength(100)]
    public string Name { get; set; }

    [MaxLength(100)]
    public string Description { get; set; }

    public static implicit operator Faculty(FacultyEnum @enum) => new Faculty(@enum);

    public static implicit operator FacultyEnum(Faculty faculty) => (FacultyEnum)faculty.Id;
}

您的模型引用了类

public class ExampleClass
{
    public virtual Faculty Faculty { get; set; }
}

创建扩展方法以从枚举和种子值中获取描述

using System;
using System.ComponentModel;
using System.Data.Entity;
using System.Data.Entity.Migrations;
using System.Linq;

public static class Extensions
{
    public static string GetEnumDescription<TEnum>(this TEnum item)
        => item.GetType()
               .GetField(item.ToString())
               .GetCustomAttributes(typeof(DescriptionAttribute), false)
               .Cast<DescriptionAttribute>()
               .FirstOrDefault()?.Description ?? string.Empty;

    public static void SeedEnumValues<T, TEnum>(this IDbSet<T> dbSet, Func<TEnum, T> converter)
        where T : class => Enum.GetValues(typeof(TEnum))
                               .Cast<object>()
                               .Select(value => converter((TEnum)value))
                               .ToList()
                               .ForEach(instance => dbSet.AddOrUpdate(instance));
}

在 Configuration.cs 中添加种子

protected override void Seed(Temp.MyClass context)
{
    context.Facultys.SeedEnumValues<Faculty, FacultyEnum>(@enum => @enum);
    context.SaveChanges();
}

在 DbContext 中添加枚举表

public class MyClass : DbContext
{
    public DbSet<ExampleClass> Examples { get; set; }
    public DbSet<Faculty> Facultys { get; set; }
}

使用它

var example = new ExampleClass();
example.Faculty = FacultyEnum.Eng;

if (example.Faculty == FacultyEnum.Math)
{
    //code
}

要记住

如果你没有在 Faculty 属性中添加 virtual，则必须使用 DbSet 中的 Include 方法进行 Eager Load

var exampleFromDb = dbContext.Examples.Include(x => x.Faculty).SingleOrDefault(e => e.Id == 1);
if (example.Faculty == FacultyEnum.Math)
{
    //code
}

如果 Faculty 属性是虚拟的，那么就使用它

var exampleFromDb = dbContext.Examples.Find(1);
if (example.Faculty == FacultyEnum.Math)
{
    //code
}

Answer 2

基于@Alberto Monteiro 的回答，我创建了通用类，以防您有多个表。这里需要注意的是Id是TEnum的类型。以这种方式使用它将提供使用 Enum 来声明属性类型的选项。

public class Question
{
    public QuestionTypeEnum QuestionTypeId { get; set; } // field property

    public QuestionType QuestionType { get; set; } // navigation property
}

默认情况下 Enum 使用整数，因此 db 提供程序将创建“int”类型的字段。

EnumTable.cs

    public class EnumTable<TEnum>
        where TEnum : struct
    {
        public TEnum Id { get; set; }
        public string Name { get; set; }

        protected EnumTable() { }

        public EnumTable(TEnum enumType)
        {
            ExceptionHelpers.ThrowIfNotEnum<TEnum>();

            Id = enumType;
            Name = enumType.ToString();
        }

        public static implicit operator EnumTable<TEnum>(TEnum enumType) => new EnumTable<TEnum>(enumType);
        public static implicit operator TEnum(EnumTable<TEnum> status) => status.Id;
    }

ExceptionHelpers.cs

static class ExceptionHelpers
{
    public static void ThrowIfNotEnum<TEnum>()
        where TEnum : struct
    {
        if (!typeof(TEnum).IsEnum)
        {
            throw new Exception($"Invalid generic method argument of type {typeof(TEnum)}");
        }
    }
}

现在你可以继承 EnumTable

public enum QuestionTypeEnum
{
    Closed = 0,
    Open = 1
}

public class QuestionType : EnumTable<QuestionTypeEnum>
{
    public QuestionType(QuestionTypeEnum enumType) : base(enumType)
    {
    }

    public QuestionType() : base() { } // should excplicitly define for EF!
}

播种价值观

context.QuestionTypes.SeedEnumValues<QuestionType, QuestionTypeEnum>(e => new QuestionType(e));

Answer 3

另一种可能性，如果你想保持你的模型更简单，POCO 风格，使用枚举作为一个属性，它将被实体框架存储为一个整数。

然后，如果您希望在数据库中创建和更新“枚举表”，我建议使用 nuget 包 https://github.com/timabell/ef-enum-to-lookup 并在 EF 迁移种子方法中使用它，例如：

public enum Shape
{
    Square,
    Round
}

public class Foo
{
    public int Id { get; set; }
    public Shape Shape { get; set; }
}

public class MyDbContext : DbContext
{
    public DbSet<Foo> Foos { get; set; }
}

using(var context = new MyDbContext())
{
    var enumToLookup = new EnumToLookup
    {
        TableNamePrefix = string.Empty,
        NameFieldLength = 50,
        UseTransaction = true
    };
    enumToLookup.Apply(context);
}

这将创建一个名为“Square”和“Round”的 2 行的“Shape”表，表“Foo”中具有相关的外键约束

Answer 4

另一种在 EF Core 中有效（我觉得更简单）的方法：

你的枚举

public enum Color
{
    Red = 1,
    Blue = 2,
    Green = 3,
}

数据库表

public class CustomObjectDto
{
    public int ID { get; set; }

    // ... other props

    public Color ColorID { get; set; }
    public ColorDto ColorDto { get; set; }
}

public class ColorDto
{
    public Color ID { get; set; }
    public string Name { get; set; }
}

你的 DbContext

public class Db : DbContext
{
    public Db(DbContextOptions<Db> options) : base(options) { }

    public DbSet<CustomObjectDto> CustomObjects { get; set; }
    public DbSet<ColorDto> Colors { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Seed database with all Colors
        foreach (Color color in Enum.GetValues(typeof(Color)).Cast<Color>())
        {
            ColorDto colorDto = new ColorDto
            {
                ID = color,
                Name = color.ToString(),
            };

            modelBuilder.Entity<ColorDto>().HasData(colorDto);
        }
    }
}

在代码中我基本上只使用枚举颜色（从不使用 ColorDto）。但是在 'CustomObjects' 表中为 sql 查询和视图提供带有 FK 的 'Colors' 表仍然很好。

Answer 5

优秀的@AlbertoMonterio！为了让它与 ASP.NET CORE / EF Core 一起使用，我对 Alberto 的解决方案进行了一些调整。

为简洁起见，以下仅显示修改：

创建扩展方法以从枚举和种子值中获取描述

using System;
using System.ComponentModel;
using System.Data.Entity;
using System.Data.Entity.Migrations;
using System.Linq;
using Microsoft.EntityFrameworkCore; //added
using Microsoft.EntityFrameworkCore.Metadata.Builders; //added

public static class Extensions
{
    //unchanged from alberto answer
    public static string GetEnumDescription<TEnum>(this TEnum item)
        => item.GetType()
               .GetField(item.ToString())
               .GetCustomAttributes(typeof(DescriptionAttribute), false)
               .Cast<DescriptionAttribute>()
               .FirstOrDefault()?.Description ?? string.Empty;

    //changed
    public static void SeedEnumValues<T, TEnum>(this ModelBuilder mb, Func<TEnum, T> converter)
    where T : class => Enum.GetValues(typeof(TEnum))
                           .Cast<object>()
                           .Select(value => converter((TEnum)value))
                           .ToList()
                            .ForEach(instance => mb.Entity<T>().HasData(instance));
}

在 Configuration.cs 中添加种子

为DataContext的OnModelCreating添加种子

protected override void OnModelCreating(ModelBuilder builder)
{
    builder.SeedEnumValues<Faculty, EnumEntityRole>(e => e);
}

Answer 6

您应该在enum 声明前添加: byte：

enum MyFieldEnum : byte{
    one = 1,
    two = 2,
    three = 4
}

在数据库中，您应该会看到TINYINT，无需强制转换！

Answer 7

我参加聚会可能有点晚了，但我没有在这里找到我想要的答案。

在 EntityFramework 文档中查找时，我找到了解决方案，这是Value Conversions 中的第一个示例

有了这个，你可以根据需要制作一个不错的扩展方法。即

public static void HasEnum<TEntity, TProperty>(this EntityTypeBuilder<TEntity> entityBuilder, Expression<Func<TEntity, TProperty>> propertyExpression)
        where TEntity : class
        where TProperty : Enum
    {
        entityBuilder.Property(propertyExpression)
            .HasConversion(
                v => v.ToString(),
                v => (TProperty)Enum.Parse(typeof(TProperty), v)
            );
    }

然后在你的 OnModelCreating 中使用它：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<YourEntity>()
        .HasEnum(e => e.YourProperty);
}

Answer 8

更新：我找到了一种在 EntityFrameworkCore 5.0.8 中运行良好的更好方法

将 JsonConverter 属性添加到您的枚举中

[Newtonsoft.Json.JsonConverter(typeof(StringEnumConverter))]
public enum FacultyEnum
{
    [EnumMember(Value = "English Professor")]
    Eng,
    [EnumMember(Value = "Math Professor")]
    Math,
    [EnumMember(Value = "Economics Professor")]
    Eco
}

创建一个代表表格的类

public class Faculty
{
    public int Id { get; set; }

    public string Name { get; set; }

    public FacultyEnum Description { get; set; }
}

在 DbContext 中的 OnModelCreating 中使用 Fluent API 以使用枚举字符串并设置检查约束

        var enumToString = new EnumToStringConverter<FacultyEnum>();
        modelBuilder.Entity<Faculty>(entity =>
        {
            entity.ToTable(nameof(FacultyMembers));
            //convert enums to string
            entity.Property(e => e.Description).HasConversion(enumToString); 
            //build check constraint from enum
            var allowedEnumStrings = string.Join(',',
                typeof(Faculty).GetMembers()
                    .Select(x => x.GetCustomAttribute(typeof(EnumMemberAttribute), false)).Where(x => x != null)
                    .Select(x => $"'{((EnumMemberAttribute)x).Value}'"));
            entity.HasCheckConstraint($"CK_{nameof(FacultyMembers)}_{nameof(Faculty.Description)}", $"{nameof(Faculty.Description)} in ({allowedEnumStrings})");
        });

老路

Alberto Monteiro 很好地回答了这个问题。我必须进行一些调整才能使其与 EF 核心一起使用。

重命名您的枚举并添加描述装饰器

public enum FacultyEnum 
{
    [Description("English Professor")]
    Eng, 
    [Description("Math Professor")]
    Math, 
    [Description("Economics Professor")]
    Eco 
}

创建一个代表表格的类

public class Faculty
{
    private Faculty(FacultyEnum @enum)
    {
        Id = (int)@enum;
        Name = @enum.ToString();
        Description = @enum.GetEnumDescription();
    }

    protected Faculty() { } //For EF

    [Key, DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int Id { get; set; }

    [Required, MaxLength(100)]
    public string Name { get; set; }

    [MaxLength(100)]
    public string Description { get; set; }

    public static implicit operator Faculty(FacultyEnum @enum) => new Faculty(@enum);

    public static implicit operator FacultyEnum(Faculty faculty) => (FacultyEnum)faculty.Id;
}

您的模型引用了类

public class ExampleClass
{
    public virtual Faculty Faculty { get; set; }
}

创建扩展方法以从枚举和种子值中获取描述

using System;
using System.ComponentModel;
using System.Data.Entity;
using System.Data.Entity.Migrations;
using System.Linq;

public static class Extensions
{
    public static string GetEnumDescription<TEnum>(this TEnum item)
        => item.GetType()
               .GetField(item.ToString())
               .GetCustomAttributes(typeof(DescriptionAttribute), false)
               .Cast<DescriptionAttribute>()
               .FirstOrDefault()?.Description ?? string.Empty;
}

在 YourDbContext.cs 中添加种子

protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Faculty>().HasData(FacultyEnum.Eng, FacultyEnum.Math, FacultyEnum.Eco);
    }

在 DbContext 中添加枚举表

public class MyClass : DbContext
{
    public DbSet<ExampleClass> Examples { get; set; }
    public DbSet<Faculty> Facultys { get; set; }
}

使用它

var example = new ExampleClass();
example.Faculty = FacultyEnum.Eng;

if (example.Faculty == FacultyEnum.Math)
{
    //code
}

要记住

如果你没有在 Faculty 属性中添加 virtual，则必须使用 DbSet 中的 Include 方法进行 Eager Load

var exampleFromDb = dbContext.Examples.Include(x => x.Faculty).SingleOrDefault(e => e.Id == 1);
if (example.Faculty == FacultyEnum.Math)
{
    //code
}

如果 Faculty 属性是虚拟的，那么就使用它

var exampleFromDb = dbContext.Examples.Find(1);
if (example.Faculty == FacultyEnum.Math)
{
    //code
}