EF 4.1代码优先-映射枚举包装为复杂类型

问题描述

| 我正在尝试为EF 4.1枚举问题构建通用解决方案。我的解决方案基本上是ef 4中如何伪造枚举的通用版本。枚举包装器类在其余代码中表现出色，并允许以下代码：

EnumWrapper<Color> c = Color.Red;

这是枚举包装类：

public class EnumWrapper<TEnum> where TEnum : struct,IConvertible
{
    public EnumWrapper()
    {
        if (!typeof(TEnum).IsEnum)
            throw new ArgumentException(\"Not an enum\");
    }

    public TEnum Enum { get; set; }

    public int Value
    {
        get { return Convert.ToInt32(Enum); }
        set { Enum = (TEnum)(object)value; }
    }

    public static implicit operator TEnum(EnumWrapper<TEnum> w)
    {
        if (w == null) return default(TEnum);
        else return w.Enum;
    }

    public static implicit operator EnumWrapper<TEnum>(TEnum e)
    {
        return new EnumWrapper<TEnum>() { Enum = e };
    }

    public static implicit operator int(EnumWrapper<TEnum> w)
    {
        if (w == null)
            return Convert.ToInt32(default(TEnum));
        else
            return w.Value;
    }
}

枚举：

public enum Color { red = 1,green = 2,blue = 3 }

POCO：

public class ChickenSandwich 
{
    public ChickenSandwich() {
        CheeseColor = new EnumWrapper<Color>();
    }

    public int ID { get; set; }
    public string Name { get; set; }
    public EnumWrapper<Color> CheeseColor { get; set; }
}

对应：

public class ColorMapping : ComplexTypeConfiguration<EnumWrapper<Color>> 
{
    public ColorMapping() {
        Ignore(x => x.Enum);
        Property(x => x.Value);
    }
}

我还尝试过将其映射到ChickenSandwich \的EntityTypeConfiguration上，如下所示：

Property(x => x.CheeseColor.Value).HasColumnName(\"CheeseColor\");

如果我将其留给ColorMapping并在ChickenSandwichMapping上不进行任何显式映射，则不会将其放入数据库中。如果我将其映射为x.CheeseColor.Value方式，则会感到恐惧：   system.invalidOperationException：   配置的属性\'CheeseColor \'是   不是该实体的声明财产   \'ChickenSandwich \'。验证它是否具有   没有明确排除在   模型，并且它是有效的原语   属性.. 编辑 我无法使枚举包装的通用版本正常工作，因此我不再编写单个包装。它并不是我想要的，因为它违反了DRY原理，但是它确实允许我将列查询为枚举。

[ComplexType]
public class ColorWrapper
{
    [NotMapped]
    public Color Enum { get; set; }

    public int Value
    {
        get { return (int)Enum; }
        set { Enum = (Color)value; }
    }

    public static implicit operator Color(ColorWrapper w)
    {
        if (w == null) return default(Color);

        return w.Enum;
    }

    public static implicit operator ColorWrapper(Color c)
    {
        return new ColorWrapper { Enum = c };
    }
}

我必须在ChickenSandwich类上使用ColorWrapper。它或多或少透明地工作。然后必须将此添加到我的映射类构造函数中以获得我想要的列名称：

Property(x => x.CheeseColor.Value).HasColumnName(\"CheeseColorId\");

    

解决方法

在EF 4中有一种更简单的映射

enums

的方法：只需在

ChickenSandwich

类上创建一个

int

属性来表示枚举的int值。那是EF应该映射的属性，然后有一个“迷你包装器”属性，可让您使用

enum

public class ChickenSandwich 
{   
    public int ID { get; set; }
    public string Name { get; set; }

    // This property will be mapped
    public int CheeseColorValue { get; set; }

    public Color CheseColor
    {
        get { return (Color) CheeseColorValue; }
        set { CheeseColorValue = (int) value; }
    }
}

实际上，我不必使用Fluent API或任何类型的属性修饰即可工作。在生成数据库时，EF将愉快地忽略它不知道如何映射的任何类型，但是

int

属性将被映射。 我也尝试根据该文章映射

enums

，但是这让我头疼不已。此方法效果很好，您可以调整解决方案以将包装器用作\“ mapping \”属性，在这种情况下为

CheeseColor

。     ,我通过简单地抽象和移动使Nathan通用枚举包装器类起作用：

public static implicit operator EnumWrapper <TEnum> (TEnum e)

到这样的派生类：

public class CategorySortWrapper : EnumWrapper<CategorySort>
{
    public static implicit operator CategorySortWrapper(CategorySort e)
    {
        return new CategorySortWrapper() { Enum = e };
    }
}

public abstract class EnumWrapper<TEnum> where TEnum : struct,IConvertible
{
    public EnumWrapper()
    {
        if (!typeof(TEnum).IsEnum)
            throw new ArgumentException(\"Not an enum\");
    }

    public TEnum Enum { get; set; }

    public int Value
    {
        get { return Convert.ToInt32(Enum); }
        set { Enum = (TEnum)(object)value; }
    }

    public static implicit operator int(EnumWrapper<TEnum> w)
    {
        if (w == null)
            return Convert.ToInt32(default(TEnum));
        else
            return w.Value;
    }
}

在我的代码中，我只是像这样使用它

public CategorySortWrapper ChildSortType { get; set; }

category.ChildSortType = CategorySort.AlphabeticOrder;

我什么也没做，EF 4.1在名为ChildSortType_Value的数据库中创建了一个\“ ComplexType like field \”     ,这可能是枚举的最佳选择，但是另一个想法是只使用常量而不是枚举：

static void Main(string[] args)
{
    Console.WriteLine(\"There are {0} red chicken sandwiches.\",sandwiches.ChickenSandwiches
                  .Where(s => s.Color == Color.red)
                  .ToArray().Length);
}

public struct Color
{
    public const int red = 1;
    public const int green = 2;
}

public class ChickenSandwich
{
    public ChickenSandwich()
    {
    }

    public int ID { get; set; }
    public string Name { get; set; }
    public int Color { get; set; }
}

public class Sandwiches : DbContext
{
    public DbSet<ChickenSandwich> ChickenSandwiches { get; set; }
}

    ,根据HenrikStenbæk的答案。 分配工作正常

category.ChildSortType = CategorySort.AlphabeticOrder

但是将包装器与其枚举进行比较是行不通的。

if(category.ChildSortType == CategorySort.AlphabeticOrder)
{

}

以下运算符应添加到抽象类中

public static implicit operator TEnum(EnumWrapper<TEnum> w)
        {
            if (w == null)
                return default(TEnum);
            else
                return w.EnumVal;
        }