Entity Framework: persistente enum in generale?

Question

Provare a creare una soluzione alternativa per l'elaborazione di Enum in Entity Framework utilizzando Generics, ma EF non sembra interessarsi alle proprietà generiche. Ad esempio:

public enum MyEnum 
{ 
    One, Two, Three 
} 

public class SomePOCOWithEnum 
{ 
     // I want this to persist as an int, but EF doesn't like generics. 
     public EnumWrapper<MyEnum> MyEnumProperty { get; set; } 
} 

L'intenzione è di mantenere l'enum come INT nel database. C'è un modo speciale di usare fluentemente o forse qualche altro metodo di meccanismo con cui posso creare detta classe generica e mantenerla come INT al database all'interno di EF?

L'intenzione è di mantenere le cose generiche come ho circa due dozzine di enumerazioni che hanno bisogno di essere persistenti, e preferisco non scrivere singole classi di wrapper per ognuna di esse.

Ecco la classe generica EnumWrapper, che dimostra quello che mi piacerebbe realizzare: conversione implicita a enum, ma la persistenza come un int:

public class EnumWrapper<T> where T : struct 
{ 
    private T enumValue; 
    public int Value 
    { 
     get { return Convert.ToInt32(enumValue); } 
     set { enumValue = (T)Enum.Parse(typeof(T), value.ToString()); } 
    } 

    public T EnumValue 
    { 
     get { return enumValue; } 
     set { enumValue = value; } 
    } 

    public static implicit operator T(EnumWrapper<T> wt) 
    { 
     return wt.EnumValue; 
    } 

    public static implicit operator EnumWrapper<T>(T t) 
    { 
     return new EnumWrapper<T>() { EnumValue = t }; 
    } 

    public override string ToString() 
    { 
     return enumValue.ToString(); 
    } 
} 

Answer 1

Come sinelaw ha già sottolineato, EF5 ha il supporto esplicito per Enum, ma se non puoi migrare ad esso per qualsiasi motivo, l'approccio che ho preso potrebbe funzionare per te.

Per questo esempio, supponiamo che la tabella sia denominata "Email" e abbiamo una colonna denominata "Priorità". Imposta la colonna come int come faresti normalmente. Successivamente, nel progetto entità, creare una classe enumerazioni che mappa i valori int:

public enum EmailPriorityEnum 
{ 
    Now = 100, 
    Soon = 1000, 
    Whenever = 10000 
} 

Infine, nel progetto entità, creare un file di classe parziale corrispondenti alla entità e mappare manualmente l'enum c'è:

public partial class Email 
{ 
    public EmailEnums.EmailPriorityEnum EmailPriority 
    { 
     get { return (EmailEnums.EmailPriorityEnum)Priority; } 
     set { Priority = (int)value; } 
    } 
} 

Da lì in poi, il codice può fare riferimento a questa proprietà in modo trasparente. Gli svantaggi principali di questo approccio sono:

1. È necessario fare attenzione che tutti i valori possibili siano mappati nell'enumerazione con gli id ​​appropriati. Per le enumerazioni che cambiano spesso questo diventa problematico.
2. Gli sviluppatori avranno ancora accesso alla colonna sottostante, a meno che non si modifichi l'accessibilità e sia possibile ignorare l'enumerazione e utilizzare qualsiasi valore desiderato.