Discussion :

[katebe]

Bonjour tous le monde
Je voudrais savoir s'il est possible de créer automatiquement un nouveau membre dans une classe.
parsqu'il m'arrive a un moment donnée dans mon projet ,que je voudrais cree une class "Champs",mais les nom de leur proprietés se defenie au cours de l'execution par un autre classe qui s'appelle "Attributs"
je voulais savoir es possible de crée des méthodes ou des membres d'une classe
dynamiquement,comment???
et merci d'avance

[Kaidan]

Rien compris, exemple bienvenue.

[Thomas Lebrun]

Rien compris, exemple bienvenue.

Entièrement d'accord: on ne comprend rien au message/problème

@katebe: Pourrais-tu, stp, réexpliquer ton problème clairement ?

[Pol63]

il est possible de créer des classes entières à la volée
mais rajoutée un membre sur une classe j'en suis beaucoup moins sûr

enfin pour celà il faut utiliser la réflection


mais il y a peut etre d'autres solutions plus simples
comme une méthode qui servirait d'appel à cette propriété virtuelle
il suffirait de donner en paramètre l'objet et le nom de la propriété voulue et ca renvoie la valeur
avec pour ca un dictionnary of (object, dictonnary of string,object))
(respectivement, objet, nom de la propriété, valeur de la propriété)

ca reste beaucoup simple à écrire je pense (l'extender de propriétés des windows forms fonctionne à peu près comme ca d'ailleurs)

[SaumonAgile]

Regarde du côté de System.Reflection.Emit (de mémoire).

[Bluedeep]

Comme Kaidan et Thomas Lebrun, je n'ai rien compris à ton problème. Quel est le besoin ? est ce a "design time" ou a "run time" ?

Si c'est a design-time, la solution passe par la création d'un add-in à Vs, si c'est a run-time, on ne peut pas rajouter de membre à une unité de compilation non-dynamique (à ma connaissance).

[Bluedeep]

Regarde du côté de System.Reflection.Emit (de mémoire).

AFAIK, cela ne permet pas de modifier un code qui n'est pas déjà dynamique (mais je peux me tromper) et, pour ce faire, CodeDom est quand même (beaucoup) plus simple d'emploi.

[SaumonAgile]

AFAIK, cela ne permet pas de modifier un code qui n'est pas déjà dynamique (mais je peux me tromper) et, pour ce faire, CodeDom est quand même (beaucoup) plus simple d'emploi.

Regarde du côté de System.Reflection.Emit (de mémoire).

J'avais prévenu

[SirJulio]

AFAIK, cela ne permet pas de modifier un code qui n'est pas déjà dynamique (mais je peux me tromper) et, pour ce faire, CodeDom est quand même (beaucoup) plus simple d'emploi.

Salut à tous (et tres bonne année 2008 par la meme =) ),

en fait, il existe une feat introduit depuis c# 2.0 qui permet de decorer à la volée un code existant au design et ce de maniere dynamique. La feat en question est appelé par 'crosoft "LCG" (Lightweight Code Generation) avec principalement la classe DynamicMethod, en essence, ca reprend le principe de l'emit (on fabrique des methodes en ecrivant directement de l'IL), mais sans l'aspect de construction du type (AssemblyBuilder => ModuleBuilder => TypeBuilder etc ...), et surtout on peut decorer un type sans besoin de le deriver. Il y a quelques limitations principalement du fait que ca ne concerne que des methodes, on ne peut ajouter des membres autres que methodes (donc on oublie les champs, ce qui peut souvent etre problematique dans les scenarios d'utilisation).

Un exemple "vite-fait" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
    class Program
    {
        public delegate void OneArgDelegate(Test p);
 
        static void Main(string[] args)
        {
            //On créé un objet Test
            Test t = new Test();
            t.Str = "Salut";
 
            DynamicMethod dyn = new DynamicMethod(
                "",                                         //Methode sans nom
                null,                                      //Retour void
                new Type[] { typeof(Test) },    //un argument (l'instance)
                typeof(Test));                        //On donne un type pour "l'etendre"
 
            ILGenerator ilGen = dyn.GetILGenerator();
 
            ilGen.Emit(OpCodes.Ldarg_0);
            ilGen.Emit(OpCodes.Ldfld, typeof(Test).GetField("m_str", 
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic));
            ilGen.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", 
                new Type[]{typeof(object)}));
            ilGen.Emit(OpCodes.Ret);
 
            //On créé un delegué (plus rapide que l'invoke)
            OneArgDelegate del = dyn.CreateDelegate(typeof(OneArgDelegate)) as OneArgDelegate;
            del(t);
 
            //On change la variable
            t.Str = "Coucou";
            del(t);
 
 
        }
    }
 
    class Test
    {
        string m_str;
        public string Str
        {
            get { return m_str; }
            set { m_str = value; }
        }
    }

On voit ici, qu'en etendant une classe on a accès à ses membres privées, que la methode créé ne peut qu'etre static et public. "L'emit lourd" (cf plus haut) peut aussi etre une solution de creation dynamique de type, mais les prerequis sont plus lourd (uniquement methode virtuelle et classe non sealed, ou alors interface connue à la compil).

Bref, ca peut etre une possibilité, mais comme toute solution à base d'emit, il faut voir si on n'essaie pas de rattraper une erreur rattrapable au design (l'emit, c'est pas vraiment facile à debugger, et pas vraiment developper-friendly, bien que tres puissant).

[katebe]

Bonjour a tout le monde..
merci beaucoup beaucoup pour vos réponces,et pardonez moi pour le retard et pour la mal explication du probléme.
j'explique a nouveau mon probléme,j'ai une classe "Table" qui est comme propriétées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
private String tableName;
        public String nomTable
        {
            get { return tableName; }
            set { tableName = value; }
        }
 
        private List<Attributs> listattributs = new List<Attributs>();
        public List<Attributs> Details
        {
            get { return listattributs; }
            set { listattributs = value; }
        }

la dernier propriétés details c'est une liste du classe " Attributs":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
private bool cleP;
        public  bool clePrimaire
        {
            get { return cleP; }
            set { cleP = value; }
        }
 
        private string nom;
        public string nomAttribut
        {
            get { return nom; }
            set { nom = value; }
        }
 
        private string type;
        public string typeAttribut
        {
            get { return type; }
            set { type = value; }
        }
 
        private bool cleE;
        public bool cleEtrangere
        {
            get { return cleE; }
            set { cleE = value; }
        }

maintenant je crée une classe "Champs" qui contient les valeur du propriete "nomAttribut" de la classe "Attributs" comme leur propre propriétés,donc au cours de chaque execution les propriétés de la classe "Champs" peuvent changée ,par rapport a les attributs saisie,c'est pour cela j'ai pensé a l'affectation des propriétés/membres dynamiquement a la classe "Champs".

et merci d'avance de vos réponce et vos critiques.

[Kaidan]

Toujours rien compris. C'est en français ? J'ai besoin d'un traducteur on dirait.

En tout cas, ça m'a l'air d'être un peu n'importe quoi comme design.
Ce que tu veux faire semble tellement simple que tu te prends la tête pour pas grand chose j'ai bien l'impression.

Il suffit de faire une classe Champs qui prend un Attribut en paramètre et le tour est joué.

[Kelpan]

Maintenant je créé une classe "Champs" qui contient les valeurs de la propriété "nomAttribut" de la classe "Attributs" comme leurs propres propriétés
Donc au cours de chaque execution les propriétés de la classe "Champs" peuvent changée, par rapport aux attributs saisis

Je crois que j'ai compris l'idée, mais je ne vois pas l'utilité !!
Comment comptes-tu te servir des propriétés de ta classe "champs" si elles n'existent qu'au moment de l'execution ?

[katebe]

bonjour à tous le monde
merci "Kelpan" de votre réponce.et pour répondre à votre question:

Comment comptes-tu te servir des propriétés de ta classe "champs" si elles n'existent qu'au moment de l'execution ?

1er: L'affecter a un DataGridViewColumns par exemple:
----------------------------------------------------------
NomAttribut1 |NomAttribut2|NomAttribut3|NomAttribut4 ...|
----------------------------------------------------------
.................|..................|..................|......................|
-----------------------------------------------------------
2eme:de sauvegarder les données saisie dans une liste de type Champs List<Champs> qui est une propriété du la Table.
si vous avez des questions a propos le probléme,je suis prêt a répondre
et merci d'avance.

[Kelpan]

Je ne vois toujours pas...

Comment peut-on utiliser les propriétés qui n'existent pas conceptuellement d'une classe ???

Pourquoi ne pas utiliser simplement une hashtable... ?

Clé = attribut

Cela serait quand même plus facile à utiliser qu'une classe avec des propriétés générées dynamiquement non ?

[Greybird]

1er: L'affecter a un DataGridViewColumns par exemple:
----------------------------------------------------------
NomAttribut1 |NomAttribut2|NomAttribut3|NomAttribut4 ...|
----------------------------------------------------------
.................|..................|..................|......................|
-----------------------------------------------------------

L'approche appropriée pour cet usage est d'implémenter ICustomTypeDescriptor sur la classe pour qu'elle fournisse dynamiquement au runtime une liste de propriétés adéquates via l'implémentation de la méthode GetProperties. Cela permet d'utiliser une collection, et notamment un dictionnaire clé/valeur pour gérer les propriétés.

Je n'ai pas très bien compris le cas 2...

[Guulh]

L'approche appropriée pour cet usage est d'implémenter ICustomTypeDescriptor sur la classe pour qu'elle fournisse dynamiquement au runtime une liste de propriétés adéquates via l'implémentation de la méthode GetProperties. Cela permet d'utiliser une collection, et notamment un dictionnaire clé/valeur pour gérer les propriétés.

Exactement. C'est ce que fait, par exemple, la DataRow ou la DataRowView, et permet de les afficher dans une DataGridView par exemple.

On sent bien que les designer de C# ont pensé dès le début à uniformiser autant que possible les mondes objet et base en regroupant le plus possible les instances de classe et les records de BDD. Pas bête