Créer automatiquement un Enum basé sur des valeurs dans une table de recherche de base de données?

Comment créer automatiquement une énumération et utiliser ensuite ses valeurs en C # en fonction des valeurs d'une table de recherche de base de données (à l'aide de la couche de données de la bibliothèque d'entreprise)?

Par exemple, si j'ajoute une nouvelle valeur de recherche dans la base de données, je ne veux pas avoir à ajouter manuellement la déclaration de valeur d'énumération statique supplémentaire dans le code - j'aimerais garder l'énumération synchronisée avec la base de données.

Existe-t-il une telle chose?

Je ne veux pas créer une énumération statique générée par du code (selon l' article du projet de code Enum Code Generator - Génération automatique de code énumération à partir de tables de recherche de base de données ) et je préférerais qu'elle soit complètement automatique.

Je fais exactement cette chose, mais vous devez faire une sorte de génération de code pour que cela fonctionne.

Dans ma solution, j'ai ajouté un projet "EnumeratedTypes". Il s'agit d'une application console qui récupère toutes les valeurs de la base de données et en construit les énumérations. Ensuite, il enregistre toutes les énumérations dans un assemblage.

Le code de génération enum est comme ceci:

// Get the current application domain for the current thread
AppDomain currentDomain = AppDomain.CurrentDomain;

// Create a dynamic assembly in the current application domain,
// and allow it to be executed and saved to disk.
AssemblyName name = new AssemblyName("MyEnums");
AssemblyBuilder assemblyBuilder = currentDomain.DefineDynamicAssembly(name,
                                      AssemblyBuilderAccess.RunAndSave);

// Define a dynamic module in "MyEnums" assembly.
// For a single-module assembly, the module has the same name as the assembly.
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(name.Name,
                                  name.Name + ".dll");

// Define a public enumeration with the name "MyEnum" and an underlying type of Integer.
EnumBuilder myEnum = moduleBuilder.DefineEnum("EnumeratedTypes.MyEnum",
                         TypeAttributes.Public, typeof(int));

// Get data from database
MyDataAdapter someAdapter = new MyDataAdapter();
MyDataSet.MyDataTable myData = myDataAdapter.GetMyData();

foreach (MyDataSet.MyDataRow row in myData.Rows)
{
    myEnum.DefineLiteral(row.Name, row.Key);
}

// Create the enum
myEnum.CreateType();

// Finally, save the assembly
assemblyBuilder.Save(name.Name + ".dll");

Mes autres projets dans la solution font référence à cet assembly généré. En conséquence, je peux ensuite utiliser les énumérations dynamiques dans le code, avec intellisense.

Ensuite, j'ai ajouté un événement post-build pour qu'après la construction de ce projet "EnumeratedTypes", il s'exécute et génère le fichier "MyEnums.dll".

En passant, cela permet de modifier l' ordre de génération de votre projet afin que "EnumeratedTypes" soit généré en premier. Sinon, une fois que vous commencez à utiliser votre .dll généré dynamiquement, vous ne pourrez pas faire de compilation si le .dll est supprimé. (Type de problème de poulet et d'oeuf - vos autres projets dans la solution ont besoin de ce .dll pour se construire correctement, et vous ne pouvez pas créer le .dll tant que vous n'avez pas créé votre solution ...)

J'ai obtenu la plupart du code ci-dessus de cet article msdn .

J'espère que cela t'aides!

Les énumérations doivent être spécifiées au moment de la compilation, vous ne pouvez pas ajouter dynamiquement des énumérations pendant l'exécution - et pourquoi le feriez-vous, il n'y aurait aucune utilisation / référence à eux dans le code?

À partir de Professional C # 2008:

Le véritable pouvoir des énumérations en C # est que, dans les coulisses, ils sont instanciés en tant que structures dérivées de la classe de base, System.Enum. Cela signifie qu'il est possible d'appeler des méthodes contre elles pour effectuer des tâches utiles. Notez qu'en raison de la façon dont le .NET Framework est implémenté, il n'y a aucune perte de performances associée au traitement syntaxique des énumérations comme des structures. En pratique, une fois votre code compilé, les enums existeront en tant que types primitifs, tout comme int et float.

Donc, je ne suis pas sûr que vous puissiez utiliser Enums comme vous le souhaitez.

Doit-il être une véritable énumération? Que diriez-vous d'utiliser un à la Dictionary<string,int>place?

par exemple

Dictionary<string, int> MyEnum = new Dictionary(){{"One", 1}, {"Two", 2}};
Console.WriteLine(MyEnum["One"]);

J'ai fait cela avec un modèle T4 . Il est assez simple de déposer un fichier .tt dans votre projet et de configurer Visual Studio pour exécuter le modèle T4 en tant qu'étape de pré-génération.

Le T4 génère un fichier .cs, ce qui signifie que vous pouvez simplement le demander à la base de données et créer une énumération dans un fichier .cs à partir du résultat. Câblé en tant que tâche de pré-construction, il recréerait votre énumération à chaque construction, ou vous pouvez exécuter le T4 manuellement si nécessaire à la place.

Disons que vous avez les éléments suivants dans votre base de données:

table enums
-----------------
| id | name     |
-----------------
| 0  | MyEnum   |
| 1  | YourEnum |
-----------------

table enum_values
----------------------------------
| id | enums_id | value | key    |
----------------------------------
| 0  | 0        | 0     | Apple  |
| 1  | 0        | 1     | Banana |
| 2  | 0        | 2     | Pear   |
| 3  | 0        | 3     | Cherry |
| 4  | 1        | 0     | Red    |
| 5  | 1        | 1     | Green  |
| 6  | 1        | 2     | Yellow |
----------------------------------

Construisez une sélection pour obtenir les valeurs dont vous avez besoin:

select * from enums e inner join enum_values ev on ev.enums_id=e.id where e.id=0

Construisez le code source de l'énumération et vous obtiendrez quelque chose comme:

String enumSourceCode = "enum " + enumName + "{" + enumKey1 + "=" enumValue1 + "," + enumKey2 + ... + "}";

(évidemment, cela est construit dans une boucle quelconque.)

Vient ensuite la partie amusante, compiler votre énumération et l'utiliser:

CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters cs = new CompilerParameters();
cp.GenerateInMemory = True;

CompilerResult result = provider.CompileAssemblyFromSource(cp, enumSourceCode);

Type enumType = result.CompiledAssembly.GetType(enumName);

Vous avez maintenant le type compilé et prêt à être utilisé.
Pour obtenir une valeur d'énumération stockée dans la base de données, vous pouvez utiliser:

[Enum].Parse(enumType, value);

où valeur peut être la valeur entière (0, 1, etc.) ou le texte / clé d'énumération (Apple, Banana, etc.)

Juste en montrant la réponse de Pandincus avec le code "de l'étagère" et quelques explications: Vous avez besoin de deux solutions pour cet exemple (je sais que cela pourrait être fait via une aussi;), laissez les étudiants avancés le présenter ...

Voici donc le DDL SQL de la table:

USE [ocms_dev]
    GO

CREATE TABLE [dbo].[Role](
    [RoleId] [int] IDENTITY(1,1) NOT NULL,
    [RoleName] [varchar](50) NULL
) ON [PRIMARY]

Voici donc le programme de la console produisant la dll:

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Data.Common;
using System.Data;
using System.Data.SqlClient;

namespace DynamicEnums
{
    class EnumCreator
    {
        // after running for first time rename this method to Main1
        static void Main ()
        {
            string strAssemblyName = "MyEnums";
            bool flagFileExists = System.IO.File.Exists (
                   AppDomain.CurrentDomain.SetupInformation.ApplicationBase + 
                   strAssemblyName + ".dll"
            );

            // Get the current application domain for the current thread
            AppDomain currentDomain = AppDomain.CurrentDomain;

            // Create a dynamic assembly in the current application domain,
            // and allow it to be executed and saved to disk.
            AssemblyName name = new AssemblyName ( strAssemblyName );
            AssemblyBuilder assemblyBuilder = 
                    currentDomain.DefineDynamicAssembly ( name,
                            AssemblyBuilderAccess.RunAndSave );

            // Define a dynamic module in "MyEnums" assembly.
            // For a single-module assembly, the module has the same name as
            // the assembly.
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule (
                    name.Name, name.Name + ".dll" );

            // Define a public enumeration with the name "MyEnum" and
            // an underlying type of Integer.
            EnumBuilder myEnum = moduleBuilder.DefineEnum (
                    "EnumeratedTypes.MyEnum",
                    TypeAttributes.Public,
                    typeof ( int )
            );

            #region GetTheDataFromTheDatabase
            DataTable tableData = new DataTable ( "enumSourceDataTable" );

            string connectionString = "Integrated Security=SSPI;Persist " +
                    "Security Info=False;Initial Catalog=ocms_dev;Data " +
                    "Source=ysg";

            using (SqlConnection connection = 
                    new SqlConnection ( connectionString ))
            {

                SqlCommand command = connection.CreateCommand ();
                command.CommandText = string.Format ( "SELECT [RoleId], " + 
                        "[RoleName] FROM [ocms_dev].[dbo].[Role]" );

                Console.WriteLine ( "command.CommandText is " + 
                        command.CommandText );

                connection.Open ();
                tableData.Load ( command.ExecuteReader ( 
                        CommandBehavior.CloseConnection
                ) );
            } //eof using

            foreach (DataRow dr in tableData.Rows)
            {
                myEnum.DefineLiteral ( dr[1].ToString (),
                        Convert.ToInt32 ( dr[0].ToString () ) );
            }
            #endregion GetTheDataFromTheDatabase

            // Create the enum
            myEnum.CreateType ();

            // Finally, save the assembly
            assemblyBuilder.Save ( name.Name + ".dll" );
        } //eof Main 
    } //eof Program
} //eof namespace 

Voici la programmation de la console imprimant la sortie (rappelez-vous qu'elle doit référencer la dll). Laissez les étudiants avancés présenter la solution pour combiner tout dans une seule solution avec un chargement dynamique et vérifier s'il existe déjà une DLL de construction.

// add the reference to the newly generated dll
use MyEnums ; 

class Program
{
    static void Main ()
    {
        Array values = Enum.GetValues ( typeof ( EnumeratedTypes.MyEnum ) );

        foreach (EnumeratedTypes.MyEnum val in values)
        {
            Console.WriteLine ( String.Format ( "{0}: {1}",
                    Enum.GetName ( typeof ( EnumeratedTypes.MyEnum ), val ),
                    val ) );
        }

        Console.WriteLine ( "Hit enter to exit " );
        Console.ReadLine ();
    } //eof Main 
} //eof Program

N'y arrivons-nous pas de la mauvaise direction?

Si les données sont susceptibles de changer pendant la durée de vie de la version déployée, une énumération n'est tout simplement pas appropriée et vous devez utiliser un dictionnaire, un hachage ou une autre collection dynamique.

Si vous savez que l'ensemble des valeurs possibles est fixe pour la durée de vie de la version déployée, une énumération est préférable.

Si vous devez avoir quelque chose dans votre base de données qui réplique l'ensemble énuméré, alors pourquoi ne pas ajouter une étape de déploiement pour effacer et remplir à nouveau la table de base de données avec l'ensemble définitif de valeurs d'énumération?

J'aime toujours écrire mon propre "enum personnalisé". Ensuite, j'ai une classe qui est un peu plus complexe, mais je peux la réutiliser:

public abstract class CustomEnum
{
    private readonly string _name;
    private readonly object _id;

    protected CustomEnum( string name, object id )
    {
        _name = name;
        _id = id;
    }

    public string Name
    {
        get { return _name; }
    }

    public object Id
    {
        get { return _id; }
    }

    public override string ToString()
    {
        return _name;
    }
}

public abstract class CustomEnum<TEnumType, TIdType> : CustomEnum
    where TEnumType : CustomEnum<TEnumType, TIdType>
{
    protected CustomEnum( string name, TIdType id )
        : base( name, id )
    { }

    public new TIdType Id
    {
        get { return (TIdType)base.Id; }
    }

    public static TEnumType FromName( string name )
    {
        try
        {
            return FromDelegate( entry => entry.Name.Equals( name ) );
        }
        catch (ArgumentException ae)
        {
            throw new ArgumentException( "Illegal name for custom enum '" + typeof( TEnumType ).Name + "'", ae );
        }
    }

    public static TEnumType FromId( TIdType id )
    {
        try
        {
            return FromDelegate( entry => entry.Id.Equals( id ) );
        }
        catch (ArgumentException ae)
        {
            throw new ArgumentException( "Illegal id for custom enum '" + typeof( TEnumType ).Name + "'", ae );
        }
    }

    public static IEnumerable<TEnumType> GetAll()
    {
        var elements = new Collection<TEnumType>();
        var infoArray = typeof( TEnumType ).GetFields( BindingFlags.Public | BindingFlags.Static );

        foreach (var info in infoArray)
        {
            var type = info.GetValue( null ) as TEnumType;
            elements.Add( type );
        }

        return elements;
    }

    protected static TEnumType FromDelegate( Predicate<TEnumType> predicate )
    {
        if(predicate == null)
            throw new ArgumentNullException( "predicate" );

        foreach (var entry in GetAll())
        {
            if (predicate( entry ))
                return entry;
        }

        throw new ArgumentException( "Element not found while using predicate" );
    }
}

Maintenant, j'ai juste besoin de créer mon énumération que je veux utiliser:

 public sealed class SampleEnum : CustomEnum<SampleEnum, int>
    {
        public static readonly SampleEnum Element1 = new SampleEnum( "Element1", 1, "foo" );
        public static readonly SampleEnum Element2 = new SampleEnum( "Element2", 2, "bar" );

        private SampleEnum( string name, int id, string additionalText )
            : base( name, id )
        {
            AdditionalText = additionalText;
        }

        public string AdditionalText { get; private set; }
    }

Enfin je peux l'utiliser comme je veux:

 static void Main( string[] args )
        {
            foreach (var element in SampleEnum.GetAll())
            {
                Console.WriteLine( "{0}: {1}", element, element.AdditionalText );
                Console.WriteLine( "Is 'Element2': {0}", element == SampleEnum.Element2 );
                Console.WriteLine();
            }

            Console.ReadKey();
        }

Et ma sortie serait:

Element1: foo
Is 'Element2': False

Element2: bar
Is 'Element2': True    

Vous voulez System.Web.Compilation.BuildProvider

Je doute également de la sagesse de faire cela, mais il y a peut-être un bon cas d'utilisation auquel je ne peux pas penser.

Ce que vous recherchez, ce sont des fournisseurs de build, à savoir System.Web.Compilation.BuildProvider

Ils sont utilisés très efficacement par SubSonic , vous pouvez télécharger la source et voir comment ils les utilisent, vous n'aurez besoin de rien d'aussi complexe que ce qu'ils font.

J'espère que cela t'aides.

Vous pouvez utiliser CodeSmith pour générer quelque chose comme ceci:

http://www.csharping.com/PermaLink,guid,cef1b637-7d37-4691-8e49-138cbf1d51e9.aspx

Je ne pense pas qu'il y ait une bonne façon de faire ce que vous voulez. Et si vous y réfléchissez, je ne pense pas que ce soit ce que vous voulez vraiment.

Si vous avez une énumération dynamique, cela signifie également que vous devez l'alimenter avec une valeur dynamique lorsque vous la référencez. Peut-être qu'avec beaucoup de magie, vous pourriez obtenir une sorte d' IntelliSense qui s'occuperait de cela et générerait une énumération pour vous dans un fichier DLL. Mais considérez la quantité de travail qu'il faudrait, à quel point il serait inefficace d'accéder à la base de données pour récupérer les informations IntelliSense ainsi que le cauchemar de la version contrôlant le fichier DLL généré.

Si vous ne voulez vraiment pas ajouter manuellement les valeurs d'énumération (vous devrez de toute façon les ajouter à la base de données), utilisez plutôt un outil de génération de code, par exemple des modèles T4 . Faites un clic droit + exécutez et vous obtenez votre énumération définie statiquement dans le code et vous obtenez tous les avantages de l'utilisation des énumérations.

L'utilisation d'énumérations dynamiques est mauvaise quelle que soit la manière. Vous devrez passer par la peine de "dupliquer" les données pour assurer un code clair et facile à maintenir dans le futur.

Si vous commencez à introduire des bibliothèques générées automatiquement, vous causez certainement plus de confusion aux futurs développeurs devant mettre à jour votre code que de simplement coder votre énumération dans l'objet de classe approprié.

Les autres exemples donnés semblent beaux et passionnants, mais pensez à la surcharge de la maintenance du code par rapport à ce que vous en retirez. De plus, ces valeurs vont-elles changer aussi fréquemment?

Une façon de conserver les énumérations et de créer une liste dynamique de valeurs en même temps consiste à utiliser les énumérations que vous avez actuellement avec un dictionnaire créé dynamiquement.

Étant donné que la plupart des Enums sont utilisés dans le contexte dans lequel ils sont définis pour être utilisés, et que les "énumérations dynamiques" seront prises en charge par des processus dynamiques, vous pouvez distinguer les 2.

La première étape consiste à créer une table / collection qui héberge les ID et les références pour les entrées dynamiques. Dans le tableau, vous incrémenterez automatiquement beaucoup plus que votre plus grande valeur Enum.

Vient maintenant la partie pour vos Enums dynamiques, je suppose que vous utiliserez les Enums pour créer un ensemble de conditions qui appliquent un ensemble de règles, certaines sont générées dynamiquement.

Get integer from database
If Integer is in Enum -> create Enum -> then run Enum parts
If Integer is not a Enum -> create Dictionary from Table -> then run Dictionary parts.

classe de générateur enum

public class XEnum
{
    private EnumBuilder enumBuilder;
    private int index;
    private AssemblyBuilder _ab;
    private AssemblyName _name;
    public XEnum(string enumname)
    {
        AppDomain currentDomain = AppDomain.CurrentDomain;
        _name = new AssemblyName("MyAssembly");
        _ab = currentDomain.DefineDynamicAssembly(
            _name, AssemblyBuilderAccess.RunAndSave);

        ModuleBuilder mb = _ab.DefineDynamicModule("MyModule");

        enumBuilder = mb.DefineEnum(enumname, TypeAttributes.Public, typeof(int));


    }
    /// <summary>
    /// adding one string to enum
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public FieldBuilder add(string s)
    {
        FieldBuilder f = enumBuilder.DefineLiteral(s, index);
        index++;
        return f;
    }
    /// <summary>
    /// adding array to enum
    /// </summary>
    /// <param name="s"></param>
    public void addRange(string[] s)
    {
        for (int i = 0; i < s.Length; i++)
        {
            enumBuilder.DefineLiteral(s[i], i);
        }
    }
    /// <summary>
    /// getting index 0
    /// </summary>
    /// <returns></returns>
    public object getEnum()
    {
        Type finished = enumBuilder.CreateType();
        _ab.Save(_name.Name + ".dll");
        Object o1 = Enum.Parse(finished, "0");
        return o1;
    }
    /// <summary>
    /// getting with index
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public object getEnum(int i)
    {
        Type finished = enumBuilder.CreateType();
        _ab.Save(_name.Name + ".dll");
        Object o1 = Enum.Parse(finished, i.ToString());
        return o1;
    }
}

créer un objet

string[] types = { "String", "Boolean", "Int32", "Enum", "Point", "Thickness", "long", "float" };
XEnum xe = new XEnum("Enum");
        xe.addRange(types);
        return xe.getEnum();