La meilleure méthode pour stocker Enum dans la Base de données

    [Required]
    public virtual int PhoneTypeId
    {
        get
        {
            return (int)this.PhoneType;
        }
        set
        {
            PhoneType = (PhoneTypes)value;
        }
    }
    [EnumDataType(typeof(PhoneTypes))]
    public PhoneTypes PhoneType { get; set; }

public enum PhoneTypes
{
    Mobile = 0,
    Home = 1,
    Work = 2,
    Fax = 3,
    Other = 4
}

Fonctionne comme un charme! Pas besoin de convertir (int)Enum ou (Enum)int dans le code. Utilisez simplement l'enum et ef le premier code permettra d'économiser de l'int pour vous. p.s.: "[EnumDataType(typeof(PhoneTypes))]" attribut n'est pas nécessaire, juste un supplément si vous voulez des fonctionnalités supplémentaires.

Sinon, vous pouvez faire:

[Required]
    public virtual int PhoneTypeId { get; set; }
    [EnumDataType(typeof(PhoneTypes))]
    public PhoneTypes PhoneType
    {
        get
        {
            return (PhoneTypes)this.PhoneTypeId;
        }
        set
        {
            this.PhoneTypeId = (int)value;
        }
    }

À la fin vous aurez besoin d'une excellente façon de traiter avec la répétition des tâches de codage tels que les enum convertisseurs. Vous pouvez utiliser un générateur de code comme MyGeneration ou CodeSmith parmi beaucoup d'autres, ou peut-être un ORM mapper comme nHibernate qui se charge de tout pour vous.

Comme pour la structure... avec des centaines d'énumérations, je voudrais d'abord envisager d'essayer d'organiser les données dans une table unique qui pourrait ressembler à quelque chose comme ceci: (pseudo sql)

MyEnumTable(
EnumType as int,
EnumId as int PK,
EnumValue as int )

qui vous permettra de stocker vos enum infos dans une table unique. EnumType pourrait également être une clé étrangère d'une table qui définit les différentes énumérations.

Votre biz objets seraient liés à cette table via EnumId. Le type enum est-il que pour l'organisation et le filtrage dans l'INTERFACE utilisateur. En utilisant tout cela dépend bien sûr de votre structure du code et du domaine du problème.

Btw, dans ce scénario, vous devez définir un index cluster sur EnumType plutôt que de laisser la valeur par défaut de cluster idx qui est créé sur le PKey.

Certaines choses que vous devriez prendre en considération.

Est l'énumération colonne va être directement utilisés par d'autres applications, comme par exemple les rapports. Cela permettra de limiter la possibilité de l'énumération d'être stockée dans son format de nombre entier parce que la valeur n'ont pas de signification lorsqu'ils sont présents dans un rapport, à moins que les rapports ont une logique personnalisée.

Quels sont les i18n besoin pour votre application? Si il prend en charge uniquement une langue, vous pouvez économiser de l'énumération comme du texte et créer une méthode d'aide à convertir à partir d'une chaîne de description. Vous pouvez utiliser [DescriptionAttribute] pour cela et méthodes pour la conversion peut probablement être trouvés par la recherche de la SORTE.

Si d'autre part vous avez besoin de langue de multiple de soutien et de l'application externe d'accès à vos données, vous pouvez commencer à envisager si l'énumération sont vraiment la réponse. Autre option, comme les tables de consultation peuvent être considérés, si le scénario est plus complexe.

Les énumérations sont excellents quand ils sont autonomes dans le code... quand ils traversent la frontière, les choses ont tendance à être un peu sale.

Mise à jour:

Vous pouvez convertir un entier en utilisant Enum.ToObject méthode. Cela implique que vous connaissez le type de l'énumération lors de la conversion. Si vous souhaitez vous rendre complètement générique, vous devez stocker le type de l'énumération à côté de la valeur dans la base de données. Vous pouvez créer dictionnaire des données de tables de soutien pour vous dire que les colonnes qui sont les énumérations et de quel type sont eux.

Je ne suis pas sûr si c'est la plus flexible, mais vous pourriez tout simplement stocker la chaîne de versions. Il est certes lisible, mais peut-être difficile à maintenir. Les Enums convertir à partir de chaînes et de retour assez facilement:

public enum TestEnum
{
    MyFirstEnum,
    MySecondEnum
}

static void TestEnums()
{
    string str = TestEnum.MyFirstEnum.ToString();
    Console.WriteLine( "Enum = {0}", str );
    TestEnum e = (TestEnum)Enum.Parse( typeof( TestEnum ), "MySecondEnum", true );
    Console.WriteLine( "Enum = {0}", e );
}

Un DB première approche peut être utilisée par la création d'un tableau cohérent pour chaque enum où la colonne Id, le nom correspond à nom de la table. Il est avantageux d'avoir les valeurs de l'enum disponibles dans la base de données à l'appui des contraintes de clés étrangères et de l'amicale des colonnes dans les vues. Nous sommes actuellement en soutenant ~100 types enum dispersés dans de nombreuses bases de données versionnées.

Pour un Code-Première de préférence, le T4 stratégie présentée ci-dessous pourrait probablement être inversé pour écrire dans la base de données.

create table SomeSchema.SomeEnumType (
  SomeEnumTypeId smallint NOT NULL primary key,
  Name varchar(100) not null,
  Description nvarchar(1000),
  ModifiedUtc datetime2(7) default(sysutcdatetime()),
  CreatedUtc datetime2(7) default(sysutcdatetime()),
);

Chaque table peut être importé en C# à l'aide d'un T4 modèle (*.tt) script.

1. Créer un "Projet de recensement". Ajouter la .tt le fichier indiqué ci-dessous.
2. Créer un sous-dossier pour chaque Schéma de Base de données nom.
3. Pour chaque type d'énumération, de créer un fichier dont le nom est SchemaName.TableName.tt. Le fichier
   les contenus sont toujours la même ligne: <#@ include
   fichier="..\EnumGenerator.ttinclude" #>
4. Ensuite pour créer/mettre à jour les énumérations, cliquez à droite sur 1 ou plusieurs fichiers et
   "Exécuter l'Outil Personnalisé" (nous n'avons pas de mise à jour automatique encore). Il va ajouter/mettre à jour un .cs fichier au projet:

en utilisant le Système.CodeDom.Compilateur; 
espace de noms TheCompanyNamespace.Les énumérations.Config 
{ 
[GeneratedCode("Auto Enum de DB Générateur", "10")] 
public enum DatabasePushJobState 
{ 
Indéfini = 0, 
Créé = 1, 
} 
public partial class EnumDescription 
{ 
public static string Description(DatabasePushJobState énumération) 
{ 
string description = "Inconnu"; 
switch (énumération) 
{ 
cas DatabasePushJobState.Undefined: 
description = "Undefined"; 
break; 

cas DatabasePushJobState.Créé: 
description = "Créée"; 
break; 
} 
retour description; 
} 
} 
//sélectionner DatabasePushJobStateId, Nom, fusionnent(Description,Nom) comme Description 
//à partir de TheDefaultDatabase.[SchName].[DatabasePushJobState] 
//1=1 order by DatabasePushJobStateId 
} 

Et, enfin, le peu gnarly T4 script (simplifié de nombreuses solutions de contournement). Il devra être adaptée à votre environnement. Un indicateur de débogage peut générer des messages dans le C#. Il y a aussi un "Debug T4 Modèle" option lors d'un clic droit sur l' .tt fichier.
EnumGenerator.ttinclude:

<#@ template debug="true" hostSpecific="true" #>
<#@ output extension=".generated.cs" #>
<#@ Assembly Name="EnvDTE" #>
<#@ Assembly Name="System.Core" #>
<#@ Assembly Name="System.Data" #>
<#@ assembly name="$(TargetPath)" #>
<#@ import namespace="EnvDTE" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Data" #>
<#@ import namespace="System.Data.SqlClient" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#  
bool doDebug = false;   //include debug statements to appear in generated output    
string schemaTableName = Path.GetFileNameWithoutExtension(Host.TemplateFile);
string schema = schemaTableName.Split('.')[0];
string tableName = schemaTableName.Split('.')[1];
string path = Path.GetDirectoryName(Host.TemplateFile);    
string enumName = tableName;
string columnId = enumName + "Id";
string columnName = "Name"; 
string columnDescription = "Description";
string currentVersion = CompanyNamespace.Enumerations.Constants.Constants.DefaultDatabaseVersionSuffix;
//Determine Database Name using Schema Name
//
Dictionary<string, string> schemaToDatabaseNameMap = new Dictionary<string, string> {
{ "Cfg",        "SomeDbName" + currentVersion },
{ "Common",     "SomeOtherDbName" + currentVersion }
//etc.     
};
string databaseName;
if (!schemaToDatabaseNameMap.TryGetValue(schema, out databaseName))
{
databaseName = "TheDefaultDatabase"; //default if not in map
}
string connectionString = @"Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=" + databaseName + @";Data Source=Machine\Instance";
schema = "[" + schema + "]";
tableName = "[" + tableName + "]";
string whereConstraint = "1=1";  //adjust if needed for specific tables
//Get containing project
IServiceProvider serviceProvider = (IServiceProvider)Host;
DTE dte = (DTE)serviceProvider.GetService(typeof(DTE));
Project project = dte.Solution.FindProjectItem(Host.TemplateFile).ContainingProject;
#>
using System;
using System.CodeDom.Compiler;
namespace <#= project.Properties.Item("DefaultNamespace").Value #><#= Path.GetDirectoryName(Host.TemplateFile).Remove(0, Path.GetDirectoryName(project.FileName).Length).Replace("\\", ".") #>
{
///<summary>
///Auto-generated Enumeration from Source Table <#= databaseName + "." + schema + "." + tableName #>.  Refer to end of file for SQL.
///Please do not modify, your changes will be lost!
///</summary>
[GeneratedCode("Auto Enum from DB Generator", "10")]
public enum <#= enumName #>
{       
<#
SqlConnection conn = new SqlConnection(connectionString);
//Description is optional, uses name if null
string command = string.Format(
"select {0}, {1}, coalesce({2},{1}) as {2}" + "\n  from {3}.{4}.{5}\n where {6} order by {0}", 
columnId,           //0
columnName,         //1
columnDescription,  //2
databaseName,       //3
schema,             //4
tableName,          //5
whereConstraint);   //6
#><#= DebugCommand(databaseName, command, doDebug) #><#
SqlCommand comm = new SqlCommand(command, conn);
conn.Open();
SqlDataReader reader = comm.ExecuteReader();
bool loop = reader.Read();
while(loop)
{
#>      ///<summary>
///<#= reader[columnDescription] #>
///</summary>
<#= Pascalize(reader[columnName]) #> = <#= reader[columnId] #><# loop = reader.Read(); #><#= loop ? ",\r\n" : string.Empty #>
<#
}
#>    }
///<summary>
///A helper class to return the Description for each enumeration value
///</summary>
public partial class EnumDescription
{
public static string Description(<#= enumName #> enumeration)
{
string description = "Unknown";
switch (enumeration)
{<#
conn.Close();
conn.Open();
reader = comm.ExecuteReader();
loop = reader.Read();
while(loop)
{#>                 
case <#= enumName #>.<#= Pascalize(reader[columnName]) #>:
description = "<#= reader[columnDescription].ToString().Replace("\"", "\\\"") #>";
break;
<# loop = reader.Read(); #>
<#
}
conn.Close();
#> 
}
return description;
}
}
/*
<#= command.Replace("\n", "\r\n        ") #>
*/
}
<#+     
private string Pascalize(object value)
{
Regex rxStartsWithKeyWord = new Regex(@"^[0-9]|^abstract$|^as$|^base$|^bool$|^break$|^byte$|^case$|^catch$|^char$|^checked$|^class$|^const$|^continue$|^decimal$|^default$|^delegate$|^do$|^double$|^else$|^enum$|^event$|^explicit$|^extern$|^$false|^finally$|^fixed$|^float$|^for$|^foreach$|^goto$|^if$|^implicit$|^in$|^int$|^interface$|^internal$|^is$|^lock$|^long$|^namespace$|^new$|^null$|^object$|^operator$|^out$|^overrride$|^params$|^private$|^protected$|^public$|^readonly$|^ref$|^return$|^sbyte$|^sealed$|^short$|^sizeof$|^stackalloc$|^static$|^string$|^struct$|^switch$|^this$|^thorw$|^true$|^try$|^typeof$|^uint$|^ulong$|^unchecked$|^unsafe$|^ushort$|^using$|^virtual$|^volatile$|^void$|^while$", RegexOptions.Compiled);
Regex rx = new Regex(@"(?:[^a-zA-Z0-9]*)(?<first>[a-zA-Z0-9])(?<reminder>[a-zA-Z0-9]*)(?:[^a-zA-Z0-9]*)");
string rawName = rx.Replace(value.ToString(), m => m.Groups["first"].ToString().ToUpper() + m.Groups["reminder"].ToString());
if (rxStartsWithKeyWord.Match(rawName).Success)
rawName =  "_" + rawName;
return rawName;    
}
private string DebugCommand(string databaseName, string command, bool doDebug)
{       
return doDebug
? "        //use " + databaseName + ";  " + command + ";\r\n\r\n"
: "";
}   
#>

Espérons-le, entity framework, un jour, le soutien d'une combinaison de ces réponses pour offrir le C# enum taper fort dans les dossiers et de la base de données mise en miroir de valeurs.