Enum généré dynamiquement

Version imprimable

Bonjour,

J'ai créé une Librairy qui contient des resources. J'aimerai, à la génération de la dll, créé dynamiquement un Enum contenant les keys présentes dans mes resources.

J'ai trouver comment faire sur la MSDN : http://msdn.microsoft.com/en-us/libr...umbuilder.aspx

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public static void Main()
    {
        // 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 aName = new AssemblyName("TempAssembly");
        AssemblyBuilder ab = currentDomain.DefineDynamicAssembly(
            aName, AssemblyBuilderAccess.RunAndSave);
 
        // Define a dynamic module in "TempAssembly" assembly. For a single-
        // module assembly, the module has the same name as the assembly.
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");
 
        // Define a public enumeration with the name "Elevation" and an 
        // underlying type of Integer.
        EnumBuilder eb = mb.DefineEnum("Elevation", TypeAttributes.Public, typeof(int));
 
        // Define two members, "High" and "Low".
        eb.DefineLiteral("Low", 0);
        eb.DefineLiteral("High", 1);
 
        // Create the type and save the assembly.
        Type finished = eb.CreateType();
        ab.Save(aName.Name + ".dll");
 
        foreach( object o in Enum.GetValues(finished) )
        {
            Console.WriteLine("{0}.{1} = {2}", finished, o, ((int) o));
        }
    }

L'inconvénient, c'est qu'il n'y a pas de : Main dans une Librairy.

Merci d'avance.

01/08/2014, 18h58
Pragmateek

Qu'est-ce que tu veux faire exactement ?

Parce que créer des enums à la volée me semble inutile en plus d'être complexe.
01/08/2014, 19h07
Pol63

enumbuilder ne sert pas à ce que tu veux faire à priori
si j'ai compris tu veux au moment de la compilation "ajouter" du code pour faire l'enum

ca doit pouvoir se faire avec du code complexe qui peut etre utilisé par le compilateur pour faire quelque chose de particulier (event pre compilation je pense)

le plus simple pour ca, c'est de se faire un générateur de code à la main, avec la reflection tu pourras trouver les ressources générées et faire le code de l'enum as string
après il te faut un moyen d'appeler ce générateur de code et coller le code généré à chaque modification avant de recompiler la dll pour la déployer
02/08/2014, 12h44
hanubis37

Détails de ma demande
Pour être exacte, j'ai créé une dll dédiée à la traduction d'un de mes logiciels en cours de développement.
Cette dll contient :
- Public Static Class MoteurTraduction
- Fichier Resources : contenant les clés pour la traduction
- Fichier Resource par langue
Dans ma Class Static, j'ai une fonction qui me retourne la chaine contenu dans le fichier resource de la CultureInfo en cours pour la clé donnée.

Code:

Public Static String GetTraductionString(string key)

Mon problème, c'est que j'ai créé mon code métier dans d'autre bibliothèque et que j'appelle méthode avec une clé saisie.

Code:

MessageBox.Show(MoteurTraduction.GetTraductionString("MessageBoxErrorNomClientTropLong"));

Je voudrais à ne pas avoir à écrire "MessageBoxErrorNomClientTropLong" mais plutôt utiliser un Enum

Code:

MessageBox.Show(MoteurTraduction.GetTraductionString(MessageBoxError.NomClientTropLong));

Je voudrais éviter de devoir écrire l'enum pour plusieurs raisons :
- Mon fichier resource contient aujourd'hui presque une centaines de clés, et je ne voudrais pas à avoir à tout écrire ou à utiliser un programme externe pour générer cet enum.
- Si je supprime une valeur de l'enum, une erreur apparaitra à la compilation de la solution. M'indiquant ainsi, que la clé supprimé était utilisée.
Est-ce que cela vous éclair ?
02/08/2014, 15h03
Pragmateek

Dans ce cas tu ne veux pas créer ton type dynamiquement à l'exécution, donc ton 1er code est inutile.

L'outil Microsoft qui serait le plus pertinent est T4 qui permet d'écrire des templates de code.
Après à voir s'il met à disposition une API permettant d'énumérer les ressources d'un autre projet...
Si oui ça devrait être plutôt aisé : en gros une boucle + quelques "prints" pour l'entête de l'enum et ses éléments.

Sinon il va falloir travailler toi même sur l'assembly de l'autre projet et utiliser CodeDom pour générer ton code C#.
02/08/2014, 15h16
hanubis37

Citation:

Envoyé par Pragmateek

Dans ce cas tu ne veux pas créer ton type dynamiquement à l'exécution, donc ton 1er code est inutile.

L'outil Microsoft qui serait le plus pertinent est T4 qui permet d'écrire des templates de code.
Après à voir s'il met à disposition une API permettant d'énumérer les ressources d'un autre projet...
Si oui ça devrait être plutôt aisé : en gros une boucle + quelques "prints" pour l'entête de l'enum et ses éléments.

Sinon il va falloir travailler toi même sur l'assembly de l'autre projet et utiliser CodeDom pour générer ton code C#.

Effectivement, en cherchant, je venais également de découvrir j la Génération de code et modèles de texte T4 : http://msdn.microsoft.com/fr-fr/library/bb126445.aspx
Cela me semble la meilleure solution. Merci pour vos conseils. Je répondre sur le sujet plus tard, pour vous dire si cela a fonctionné et comment j'ai fait.

A+ et bon courage à tous.

Première Solution

Bonjour à tous, voici le code que j'ai mis en place et qui fonctionne.

Dans le projet de ma bibliothèque, j'ai créé un fichier ce nommant : "AssemblyInfo.tt" dans le répertoire : Properties
Je l'ai inclus dans mon projet. Ensuite, j'ai ouvert le fichier : "AssemblyInfo.tt" dans Visual Studio 2012.

A l'intérieur de celui-ci j'ai écrit :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Windows.Forms" #>
<#@ import namespace="System.Resources" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.ComponentModel.Design" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Reflection" #>
<#
 
    var nameSpace = "Superviseur.LangageRessources";
    var enumSubName ="Resx";
    var enumValidator = "Validator";
    var enumMessageBox ="MessageBox";
    var enumButton ="Button";
    var enumOther = "Other";
 
    var fileName = "Resources.resx";
    var filePath = Path.Combine(Path.GetDirectoryName(this.Host.ResolvePath("")), "Properties", fileName);
 
    var filettcs = "AssemblyInfo1.cs";
    var filePathttcs = Path.Combine(Path.GetDirectoryName(this.Host.ResolvePath("")), "Properties", filettcs);
    System.IO.StreamWriter writer = new StreamWriter(filePathttcs, false);
    writer.Write("");
    writer.Close();
 
 
    using (var reader = new ResXResourceReader(filePath))
    {
        reader.UseResXDataNodes = true;
 
		List<DictionaryEntry> listeValidator = new List<DictionaryEntry>();
		List<DictionaryEntry> listeMessageBox = new List<DictionaryEntry>();
		List<DictionaryEntry> listeButton = new List<DictionaryEntry>();
		List<DictionaryEntry> listeOther = new List<DictionaryEntry>();		
 
		foreach(DictionaryEntry entry in reader) 
		{
			string keyName = entry.Key.ToString();
 
			if (keyName.StartsWith(enumValidator))
			{
				listeValidator.Add(entry);
			}else
			{
				if (keyName.StartsWith(enumMessageBox))
				{
					listeMessageBox.Add(entry);
				}else
				{
					if (keyName.StartsWith(enumButton))
					{
						listeButton.Add(entry);
					}else
					{
						listeOther.Add(entry);
					}
				}
			}			
		} 
#>
namespace <#=nameSpace#>
{
    public enum <#=enumSubName + enumValidator#>
    {
        <#  foreach(DictionaryEntry entry in listeValidator) { 
            var name = entry.Key;
            var node = (ResXDataNode)entry.Value;
            var value = node.GetValue((ITypeResolutionService) null);
            var comment = node.Comment;
            var summary = value;
            if (!String.IsNullOrEmpty(comment)) summary += " - " + comment;
        #>
 
        /// <summary>
        /// <#= summary #>
        /// </summary>
        <#= name #>,
        <# } #>
 
    }
 
	public enum <#=enumSubName + enumMessageBox#>
    {
        <#  foreach(DictionaryEntry entry in listeMessageBox) { 
            var name = entry.Key;
            var node = (ResXDataNode)entry.Value;
            var value = node.GetValue((ITypeResolutionService) null);
            var comment = node.Comment;
            var summary = value;
            if (!String.IsNullOrEmpty(comment)) summary += " - " + comment;
        #>
 
        /// <summary>
        /// <#= summary #>
        /// </summary>
        <#= name #>,
        <# } #>
 
    }
 
	public enum <#=enumSubName + enumButton#>
    {
        <#  foreach(DictionaryEntry entry in listeButton) { 
            var name = entry.Key;
            var node = (ResXDataNode)entry.Value;
            var value = node.GetValue((ITypeResolutionService) null);
            var comment = node.Comment;
            var summary = value;
            if (!String.IsNullOrEmpty(comment)) summary += " - " + comment;
        #>
 
        /// <summary>
        /// <#= summary #>
        /// </summary>
        <#= name #>,
        <# } #>
 
    }
 
	public enum <#=enumSubName + enumOther#>
    {
        <#  foreach(DictionaryEntry entry in listeOther) { 
            var name = entry.Key;
            var node = (ResXDataNode)entry.Value;
            var value = node.GetValue((ITypeResolutionService) null);
            var comment = node.Comment;
            var summary = value;
            if (!String.IsNullOrEmpty(comment)) summary += " - " + comment;
        #>
 
        /// <summary>
        /// <#= summary #>
        /// </summary>
        <#= name #>,
        <# } #>
 
    }
 
}
 
 
<#
    }
#>

Ce code me permet de séparer les clés présentent dans mon fichier ressource, par rapport au début des chaînes de caractère de celles-ci.
Une fois les clés triées dans mes listes, je génère le code C# me permettant de créer mes Enums dynamiquement.

Si vous avez des avis sur mon code pour le rendre plus propre, je suis preneur.

Merci encore pour votre aide.

Le seul truc que je verrais bien autrement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (keyName.StartsWith(enumValidator))
{
    listeValidator.Add(entry);
}
else if (keyName.StartsWith(enumMessageBox))
{
    listeMessageBox.Add(entry);
}
else if (keyName.StartsWith(enumButton))
{
    listeButton.Add(entry);
}
else
{
    listeOther.Add(entry);
}

Sinon très joli travail, c'est sûr ça servira à d'autres. :)

06/08/2014, 09h26
hanubis37

Problème avec T4

Salut,

j'ai remarqué un petit inconvénient à l'utilisation de T4, il exécute le code du fichier "*.tt" uniquement lorsque celui-ci a été modifié.
J'ai cherché toute la journée d'hier pour trouver comment forcer son exécution, sans réussir.

J'ai trouvé ce site qui me paraissait bien sans réussir à le faire fonctionner
http://blogs.clariusconsulting.net/k...al-studio-sdk/

Est-ce quelqu'un connait une solution ?

Merci.