PropertyGrid pour collection d'objet dynamiques

Version imprimable

16/09/2011, 17h49
Spidyy

PropertyGrid pour collection d'objet dynamiques
Bonjour a tous.

Je cherche a utiliser une Windows.Forms.PropertyGrid pour afficher dynamiquement le contenu d'un fichier XML. Mon soucis est que je comprend comment afficher les propriétés d'un objet simple, mais je ne trouve pas de méthode pour afficher le contenu d'une liste comme si c’était un objet.

Je m'explique peut-etre mal, donc voici un exemple :

J'ai un fichier xml comme suis :
Code:

1 2 3 4 5 6 <object> <variable name="Range" value="30" /> <variable name="Life" value="100" /> <variable name="Name" value="Wood Bow" /> </object>
J'aimerais que ma PropertyGrid affiche une ligne par node "variable", avec en label le "name" de la variable et en valeur le contenu du champ "value".

Aussi, j'ai du mal a comprendre comment interragissent entre eux les objets de type Component, Attribute, PropertyDescriptor, UITypeEditor, enfin tout ce qui tourne autour de la programmation des PropertyGrid.

Je me suis aide de cette page pour essayer de comprendre, mais ca reste pas clair. :(

Je ne sais pas si le sérialiseur Xml .NET te permet de désérialiser directement en objet sans préciser le type.

Tu peux toujours générer un objet disposant des mêmes propriétés que ton objet sérialisé.

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
        public static object CreateDynamicClass(XDocument doc)
        {
            var asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("DynAsm"), AssemblyBuilderAccess.RunAndSave);
 
            var modBuilder = asmBuilder.DefineDynamicModule("DynMod", "DynAsm.dll", true);
 
            var type = modBuilder.DefineType("DynType", TypeAttributes.Public);
 
            //Create the ctor
            var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
 
            var il = ctor.GetILGenerator();
 
            foreach (var field in doc.Root.Elements())
            {
                if (field.Attribute("name") == null || field.Attribute("value") == null)
                    continue;
 
                var name = field.Attribute("name").Value;
                var value = field.Attribute("value").Value;
 
                //Define a new field
                var fieldInfo = type.DefineField("_" + name, typeof(string), FieldAttributes.Private);
 
                //Define a new property
                var propertyInfo = type.DefineProperty(name, PropertyAttributes.HasDefault, typeof(string), Type.EmptyTypes);
 
                //Bind property getter to the field
                var getter = type.DefineMethod("get_" + name, MethodAttributes.Public, typeof(string), Type.EmptyTypes);
                var ilGet = getter.GetILGenerator();
 
                ilGet.Emit(OpCodes.Ldarg_0); // Push current instance on the stack
                ilGet.Emit(OpCodes.Ldfld, fieldInfo); // Push field value
                ilGet.Emit(OpCodes.Ret); //return
 
                //Bind property setter to the field
                var setter = type.DefineMethod("set_" + name, MethodAttributes.Public, null, new[] { typeof(string) });
                var ilSet = setter.GetILGenerator();
 
                ilSet.Emit(OpCodes.Ldarg_0); // Push current instance on the stack
                ilSet.Emit(OpCodes.Ldarg_1); // Push value
                ilSet.Emit(OpCodes.Stfld, fieldInfo); // Save value to field
                ilSet.Emit(OpCodes.Ret);
 
                propertyInfo.SetGetMethod(getter);
                propertyInfo.SetSetMethod(setter);
 
                //Set field value
                il.Emit(OpCodes.Ldarg_0); // Push current instance on the stack
                il.Emit(OpCodes.Ldstr, value); //Push string
                il.Emit(OpCodes.Stfld, fieldInfo); // Set field with popped value
            }
 
            il.Emit(OpCodes.Ret);
 
            return Activator.CreateInstance(type.CreateType());
        }

Pour l'utiliser, rien de plus simple :

Code:

propertyGrid1.SelectedObject = CreateDynamicClass(XDocument.Load(@".\test.xml"));

Pour te renseigner sur les attributs pour personnaliser l'affichage des objets dans la pGrid je te conseille plutôt ce lien : http://msdn.microsoft.com/en-us/library/aa302326.aspx

16/09/2011, 19h45
Spidyy
Sympa la construction de classe "a la volée".

Bon jvais detailler un peu mon probleme.

Le XML represente le debut de la chaine et la PropertyGrid est un intermediaire.

En gros, mon truc fait ca :
1. Mon programme lit le XML et construit une representation dans un TreeNode.
2. Dans les Node de la TreeNode sont sauve le nom des attributs, leur type et leur valeur sous forme de String
3. A la seleciton d'un Node, je liste ses variables dans la PropertyGrid. Bien sur, les modif dans la PropertyGrid change les valeurs des variables.
4. Avant de fermer le programme, je sauvegarde mon arbre sous forme de fichiers XML
Donc la difficulte, c'est deja de peupler la PropertyGrid, mais apres de lier les editor de la propertyGrid aux donnees des Node du TreeNode.

La solution que tu me propose permet d'afficher les variables du xml dans la PropertyGrid, mais comment je peux gerer pour lier les donnees avec les editors de la PropertyGrid?

Bien mieux le lien que tu m'a passe aussi. :)