Discussion :

[kheironn]

Bonjour,
j'ai codé une classe générique qui me permet de faire des conversions du contenu de toute les propriétés de type string d'une classe de type T.
Mais voilà, ma classe T peut contenir des types non primitifs et je souhaites rentrer dans ces types et appliquer la conversion. Bref faire de la récursivité si possible.

voici ma classe :

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
    public class FieldConvertor<T> where T : new()
    {
        public T Item { get; set; }
 
        public FieldConvertor(object item)
        {
            Item = (T)item;
        }
 
        public T ConvertStringPropertiesToHtmlTag()
        {
            PropertyInfo[] properties = typeof(T).GetProperties();
            foreach (PropertyInfo property in properties)
                if (property.PropertyType.Name == typeof(string).Name)
                {
                    object propertyValue = property.GetValue(this.Item, null);
                    if (propertyValue != null && property.GetSetMethod() != null)
                        property.SetValue(this.Item, propertyValue.ToString().Replace("[[", "<").Replace("]]", ">"), null);
                }
            return this.Item;
        }
 
        public T ConvertStringPropertiesFromHtmlTag()
        {
            PropertyInfo[] properties = typeof(T).GetProperties();
            foreach (PropertyInfo property in properties)
                if (property.PropertyType.Name == typeof(string).Name)
                {
                    object propertyValue = property.GetValue(this.Item, null);
                    if (propertyValue != null && property.GetSetMethod() != null)
                        property.SetValue(this.Item, propertyValue.ToString().Replace("<", "[[").Replace(">", "]]"), null);
                }
            return this.Item;
        }
    }

Mon problème est comment récupérer le type T2 dans une List<T2>, par exemple, afin de faire de la récursivité ?

Au passage, si vous avez une remarque pour améliorer, n'hésitez-pas.

Voici un exemple d'utilisation :

Code :

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

1
2
3
4
5
6
        public ViewResult Details(int id)
        {
            Character character = db.Characters.Find(id);
            character = new FieldConvertor<Character>(character).ConvertStringPropertiesToHtmlTag();
            return View(character);
        }

[Pol63]

pas trop regardé le code mais pour faire ca il ne faut pas de generics je pense mais juste un parametre Object

sur la classe Objet il y a .GetType qui permet de connaitre le type et de faire de la reflection, la récursivité est alors possible

[kheironn]

Merci de ta réponse, je vais essayer de dégager les generics.

[neilbgr]

Mais pourquoi jeter les génériques ? surtout que le conseil est donné par une personne qui a l'honnêteté de dire qu'il n'a même pas lu le code !?

En gardant les génériques, il te suffit de faire la "reflection" sur le type, et il y a (évidement) tout ce qu'il faut pour traiter les types génériques.
Voir notamment la méthode GetGenericArguments et les autres membres de la classe Type.

[Pol63]

on peut planter des clous avec une masse mais le marteau reste quand même plus adapté

les generics c'est bien, mais je ne vois pas ce que ca apporte ici, et donc si ca ne sert à rien autant s'en passer
l'utilité des generics c'est de pouvoir retourner des valeurs typées, ici je ne vois pas l'interet de retourner l'instance

le code je l'avais lu, c'est juste que quand je prends pas le temps de passer par un convertisseur c#/vb.net je préfère pondérer ma réponse ; là je l'ai converti

[kheironn]

Bonjour,
J'utilise ensuite l'instance retournée dans mon return view(instance).
C'est ce qui m'a fait pencher pour l'utilisation de génériques.

@neilbgr : j'ai vu ces méthodes, mais je n'ai pas dû m'en servir correctement, car je n'obtenais pas le résultat attendu.

Mon but est d'identifier les List<T> dans une instance afin d'y entrer et de faire les mêmes modifs que dans mon instance principale.
Identifier que c'est une List, facile, mais le Type T là ??? Je me suis basé sur le FullName de PropertyType et ça marche.

Ensuite je suis confronté au fait que je ne peux pas utiliser un Foreach pour modifier directement les instances de l'itération. Donc je voulais créer une List<T> où T serait le type que j'ai identifié. Mais là nouveau blocage !
impossible de faire List<TypeOf(...)> ou List<MonType.GetType()>...
une idée ?

Pour le moment, j'ai fait des méthodes que j'appelle explicitement dans mon contrôleur, mais il serait préférable de tout faire en un seul appel de méthode.

[Pol63]

voici une méthode qui transforme les "a" en "b" sur tout
si on lui donne un string, ca fonctionne
si on lui donne une classe, ca transforme les propriétés string de la classe et les propriétés des propriétés qui sont des classes
ca fonctionne aussi pour les propriété list T (T étant un classe ou T étant un string)

pas testé sur des list T en entrée, mais ca ne doit pas fonctionner, mais ca peut se rajouter

il n'y a pas de generics, car je continue de penser que tu n'en as pas besoin

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
47
48
49
50
51
52
53
54
55
56
57
58
public class StrTransform
{
    public static void Transform(ref object o)
    {
        try {
            if (o == null)
                return;
 
            if (o is string) {
                o = ((string)o).Replace("a", "b");
                return;
            }
 
 
            foreach (object p_loopVariable in o.GetType().GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)) {
                p = p_loopVariable;
                switch (true) {
                    case object.ReferenceEquals(p.PropertyType, typeof(string)):
                        string currentValue = (string)p.GetValue(o, null);
                        p.SetValue(o, currentValue.Replace("a", "b"), null);
 
                        break;
                    case p.PropertyType.GetInterfaces.Contains(typeof(IEnumerable)):
                        IEnumerable values = (IEnumerable)p.GetValue(o, null);
 
                        if (values.GetType().IsGenericType && object.ReferenceEquals(values.GetType().GetGenericArguments(0), typeof(string))) {
                            dynamic values2 = (IEnumerable<string>)p.GetValue(o, null);
                            for (int i = 0; i <= values2.Count - 1; i++) {
                                string valeurStr = values2(i);
                                if (valeurStr.Contains("a")) {
                                    values2.GetType().GetProperty("Item").SetValue(values2, valeurStr.Replace("a", "b"), new object[1] { i });
                                }
                            }
 
 
                        } else {
                            foreach (object v_loopVariable in values) {
                                v = v_loopVariable;
                                StrTransform.Transform(ref v);
                            }
                        }
 
                        break;
                    case p.PropertyType.IsClass:
                        StrTransform.Transform(ref p.GetValue(o, null));
 
                        break;
 
 
                }
            }
        } catch (Exception ex) {
            dynamic s = ex.Message;
        }
    }
 
 
}

(converti du vb.net)

[Guulh]

Hello,
je suis d'accord avec Pol63, nul besoin de generics ici. Dès qu'on touche à la réflexion, que ce soit pour de la sérialisation ou du binding par exemple, on a pas accès aux objects via des références sur leur type exact.
Je propose donc:

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
    public class StrTransform
    {
        public static void Transform(object o)
        {
            if (o == null)
                return;
            var enumerable = o as System.Collections.IEnumerable;
            if (enumerable != null)
            {
                foreach(var subobject in enumerable)
                    Transform(subobject);
            }
 
            foreach (var p in o.GetType().GetProperties()
                .Where(p => p.CanRead && p.CanWrite))
            {
                var value = p.GetValue(o, null);
                var str = value as string;
                if (str != null)
                    p.SetValue(o, str.Replace("a", "b"), null);
                else
                    Transform(value);
            }
        }
    }

Pas testé, ni protégé contre les StackOverflow, mais bon

[neilbgr]

Je suis d'accord avec vous, et notamment avec la proposition de Guulh.

[Sehnsucht]

Personnellement je me suis attaqué au problème (enfin ce que je pense en avoir compris) en mélangeant les deux idées, conserver du générique là où on peut/veut et pour le reste quelque chose de plus conventionnel.
J'aurais bien vu une sorte de pattern visiteur mais là j'ai du mal à voir comment le mettre en place.
De plus j'ai ajouté la possibilité de choisir l'action a faire de manière générique via une lambda (et les exemples montrent deux possibilité ; remplacer les "b" en "B" et multiplier les entier par 2)
Il doit manquer possiblement des cas d'erreur et je ne gère que les List<> mais ça peut donner une base de réflection()

Donc je ne sais pas si ça convient mais de toute manière ça peut pas faire de mal de le poster (au pire on se fichera de moi )

Les classes bidons pour tester et le Main

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
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
using System;
using System.Collections.Generic;
using System.Linq;
 
namespace TypeVisiting
{
    class Foo
    {
        public string Bar { get; set; }
        public int Baz { get; set; }
    }
 
    class Bar
    {
        public List<string> Values { get; set; }
    }
 
    class Baz
    {
        public List<Foo> Foos { get; set; }
    }
 
    class Qux
    {
        public List<Baz> Bazes { get; set; }
    }
 
    class Program
    {
        static void Main ()
        {
            var in1 = "abcd";
            var out1 = Transform<string, string> (in1, s => s.Replace ("b", "B"));
 
            var in2 = new Foo {
                Bar = "abcd",
                Baz = 1
            };
            var out2_1 = Transform<Foo, string> (in2, s => s.Replace ("b", "B"));
            var out2_2 = Transform<Foo, int> (in2, n => n * 2);
 
            var in3 = new Bar {
                Values = new List<string> {
                    "abcd",
                    "bcde"
                }
            };
            var out3 = Transform<Bar, string> (in3, s => s.Replace ("b", "B"));
 
            var in4 = new Baz {
                Foos = new List<Foo> {
                    new Foo {
                        Bar = "abcd", Baz = 1
                    },
                    new Foo {
                        Bar = "bcde",
                        Baz = 2
                    }
                }
            };
            var out4_1 = Transform<Baz, string> (in4, s => s.Replace ("b", "B"));
            var out4_2 = Transform<Baz, int> (in4, n => n * 2);
 
            var in5 = new Qux {
                Bazes = new List<Baz> {
                    new Baz {
                        Foos = new List<Foo> {
                            new Foo {
                                Bar = "abcd",
                                Baz = 1
                            },
                            new Foo {
                                Bar = "bcde",
                                Baz = 2
                            }
                        }
                    },
                    new Baz {
                        Foos = new List<Foo> {
                            new Foo {
                                Bar = "dcba",
                                Baz = 3
                            },
                            new Foo {
                                Bar = "edcb",
                                Baz = 4
                            }
                        }
                    }
                }
            };
            var out5_1 = Transform<Qux, string> (in5, s => s.Replace ("b", "B"));
            var out5_2 = Transform<Qux, int> (in5, n => n * 2);
        }

Le coeur de l'action

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
        static T Transform<T, TProp> (T source, Func<TProp,TProp> selector)
        {
            return (T) TransformImpl (typeof (T), source, selector);
        }
 
        private static object TransformImpl<TProp> (Type type, object source, Func<TProp,TProp> selector)
        {
            if (type == typeof (TProp))
                return selector ((TProp) source);
 
            var properties = type.GetProperties ().Where (p => p.CanWrite && !p.GetIndexParameters ().Any ());
            foreach (var property in properties)
            {
                var propType = property.PropertyType;
 
                property.SetValue (source,
                    propType.IsGenericType && propType.GetGenericTypeDefinition () == typeof (List<>) ?
                    TransformListImpl (propType.GetGenericArguments ().Single (), property.GetValue (source), selector) :
                    TransformImpl (propType, property.GetValue (source), selector));
            }
            return source;
        }
 
        private static object TransformListImpl<TProp> (Type type, object source, Func<TProp, TProp> selector)
        {
            var genType = typeof (List<>).MakeGenericType (new[] { type });
            var count = (int) genType.GetProperty ("Count").GetValue (source);
 
            for (int i = 0; i < count; ++i)
            {
                var itemProp = genType.GetProperty ("Item");
                var index = new object[] { i };
                itemProp.SetValue (source, TransformImpl (type, itemProp.GetValue (source, index), selector), index);
            }
            return source;
        }
    }
}

[kheironn]

Merci à de m'avoir consacré du temps.
J'ai consulté vos propositions et je vais m'en inspirer pour régler mon problème.

[kheironn]

finallement, j'ai adopté cette sollution :

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
47
48
    public class FieldConvertor
    {
        public enum ConvertMode { HtmlToWiki, WikiToHtml }
 
        private static string GetTransformations(string stringToTransform, ConvertMode mode)
        {
            switch (mode)
            {
                case ConvertMode.HtmlToWiki:
                    stringToTransform = stringToTransform.Replace("<", "[[").Replace(">", "]]");
                    break;
                case ConvertMode.WikiToHtml:
                    stringToTransform = stringToTransform.Replace("[[", "<").Replace("]]", ">");
                    break;
                default:
                    break;
            }
            return stringToTransform;
        }
 
        public static void ConvertStringPropertiesTags(object objectToConvert, ConvertMode mode)
        {
            if (objectToConvert == null)
                return;
 
            var enumerable = objectToConvert as IEnumerable;
            if (enumerable != null)
                foreach (var item in enumerable)
                {
                    ConvertStringPropertiesTags(item, mode);
                    return;
                }
 
            PropertyInfo[] properties = objectToConvert.GetType().GetProperties();
            foreach (PropertyInfo property in properties)
            {
                object propertyValue = property.GetValue(objectToConvert, null);
                if ((propertyValue as IEnumerable) != null && (propertyValue as IEnumerable) is ICollection)
                    ConvertStringPropertiesTags(propertyValue, mode);
 
                if (property.PropertyType != typeof(string))
                    continue;
 
                if (propertyValue != null && property.GetSetMethod() != null)
                    property.SetValue(objectToConvert, GetTransformations(propertyValue.ToString(), mode), null);
            }
        }
    }

J'ai du régler un problème de réferences circulaires lié a EntityFramework entre instance encapsulente et instance encapsulée (qui encapsule l'encapsulente)...

Il me reste un dernier pbm lié à la vue cette fois :

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
    @if (Model.History != null)
    {
        <fieldset>
            <legend>Histoire du personnage</legend>
            <div class="display-field">
                <table width="100%">
                    @foreach (var historicalEvent in Model.History)
                    {
                        <tr>
                            <td style="width: 10%">
                                @historicalEvent.StandartYear
                            </td>
                            <td style="width: 90%">
                                @historicalEvent.Description
                            </td>
                        </tr>
                    }
                </table>
            </div>
        </fieldset>
    }

ma description est du HTML (grace aux remplacements faits avec notre méthode) et je en sais pas trop comment l'afficher correctement les Html.Display... ne semblent pas pouvoir utiliser historicalEvent...

[kheironn]

J'ai retrouvé la syntaxe dans ce tutoriel :

Code :

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

@Html.DisplayTextFor(modelItem => historicalEvent.Description)