Méthode "propre" pour qu'un élément d'une liste puisse propager des choses à la liste ?

**StringBuilder** · 29/10/2014, 17h16

Bonjour,

J'ai une liste (classe munie d'un indexeur), dans laquelle je ne veux pas de doublons.

Donc lorsque je fais un :

Code csharp :

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

1
2
 
maliste[i].ChangeLaValeur();

Je voudrais que mon élément dire "ok, maintenant, lance la méthode check()" de la liste.

Comment faire ?

Je passerais bien une référence à la liste sur chacun des éléments, mais c'est pas terrible, si ?

**lead8209** · 30/10/2014, 14h16

Salut, bof bof la ref à tous les items... moi je te propose de passer par un événement tout simplement.
Ci-dessous un exemple basique à adapter à ta solution :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
//un petit main qui ressemble à ce que tu as demandé dans ton post
static void Main()
        {
 
            Liste liste = new Liste();
            liste.Add(new Item() { id = 1 });
            liste.Add(new Item() { id = 2 });
            liste.Add(new Item() { id = 3 });
 
            liste[0].id = 5; //console --> Item changed running check
 
            Console.ReadLine();
        }

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
 
//la classe de données qui contient l'événement lancé à chaque fois qu'une propriété est modifiée.
//Ici seule la prop id est contrôlée
class Item
    {
        public delegate void ChangedEvent(Item pItem);
        public event ChangedEvent changed;
 
        protected virtual void OnChanged()
        {
            if (changed != null)
            {
                changed(this);
            }
        }
 
        private int _id;
        public int id
        {
            get { return _id; }
            set { _id = value; OnChanged(); }
        }
    }

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
 
//la classe liste qui stocke les données et qui et qui s'abonne à l'événement "Changed" des items qu'elle stocke à chaque fois qu'on lui en rajoute un.
//désabonnement quand l'item est supprimé de la liste.
//enfin à toi de voir le comportement que tu souhaites adopter et surtout le contrôle que tu souhaites effectuer dans la méthode "Check"
class Liste : List<Item>
    {
        public new void Add(Item pItem)
        {
            pItem.changed += new Item.ChangedEvent(Check);
            base.Add(pItem);
        }
 
        public new void Remove(Item pItem)
        {
            pItem.changed -= Check;
            base.Remove(pItem);
        }
 
        private void Check(Item pItem)
        {
            Console.WriteLine("Item changed running check");
            for (int i = 0; i < this.Count; i++)
            {
                //check other ids
            }
        }
    }

Voila une solution. Tu me dis si ça te convient.

**StringBuilder** · 30/10/2014, 15h29

La méthode me va, et c'est effectivement ce que j'ai commencé à implémenter.

En revanche, j'ai un léger souci.

Pour faire simple, mon objet est une sorte de Datatable.

J'ai donc :
- Une liste qui contient la définition des colonnes
- Une liste de liste qui contient pour chaque ligne, les valeurs de chaque colonne.

Et mon indexeur porte sur la ligne.

Sauf que lorsque j'accède à une ligne, au lieu de retourner le List<UnType> qui correspond à la ligne demandée, je renvoie une instance vers un nouvel objet qui contient :
- Une référence vers la liste des colonnes
- Une référence vers le List<UnType>

Et cet objet dispose lui-même d'un indexeur, permettant, à partir d'un nom de colonne, de retrouver l'élément de la liste qui contient la valeur.

Maintenant mon objet principal dispose d'un méchanisme de contrôle de la cohérence de son contenu : interdit d'avoir deux lignes identiques.

Et donc, quand je fais :

Code csharp :

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

1
2
 
MonObject[12]["MaColonne"] = new UnType("nouvelle valeur");

Je n'arrive pas à trouver à quoi doit s'abonner "MonObjet" pour détecter le remplacement de ma valeur... étant donné que :
- Elle est écrasée (donc pas de méthode appelable du genre "UpdateValeur(nouvellevaleur)"
- Que "MonObjet[12]" n'est créé que le temps de l'affectation de la valeur
- Et du coup que j'ai très mal à a tête depuis deux jours

**lead8209** · 30/10/2014, 16h19

Ton code est confidentiel ?
Enfin le bout que tu cherches à développer. Si possible en standalone bien séparé du reste du projet quoi.
Car je comprends bien tous les mots que tu utilises sauf qu'à représenter mentalement quand on connait pas le type de données utilisé et à quoi cela correspond dans la réalité c'est trop dur

Si tu postes je vais voir si je peux te trouver une petite solution. Sinon impossible comme ça.

**StringBuilder** · 30/10/2014, 16h19

J'ai réécrit en vitesse un prototype de ce que je veux faire :

Code csharp :

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
95
 
using System;
using System.Collections.Generic;
 
namespace AccessorTest
{
    public class Value
    {
        public string value = string.Empty;
 
        public Value(string value)
        {
            this.value = value;
        }
    }
 
    public class Record
    {
        private List<string> Columns;
        private List<Value> Values;
 
        public Record(List<string> columns, List<Value> values)
        {
            this.Columns = columns;
            this.Values = values;
        }
 
        public Value this[int Index]
        {
            get
            {
                return Values[Index];
            }
            set
            {
                Values[Index] = value;
            }
        }
 
        public Value this[string Column]
        {
            get
            {
                for (int i = 0, cpt = Columns.Count; i < cpt; i++)
                {
                    if (Columns[i] ==  Column)
                    {
                        return Values[i];
                    }
                }
                throw new KeyNotFoundException();
            }
            set
            {
                for (int i = 0, cpt = Columns.Count; i < cpt; i++)
                {
                    if (Columns[i] ==  Column)
                    {
                        Values[i] = value;
                        break;
                    }
                }
            }
        }
 
        public List<Value> GetValues()
        {
            return Values;
        }
    }
 
    public class MonDT
    {
        private List<List<Value>> Values;
        private List<string> Columns;
 
        public MonDT(List<string> columns, List<List<Value>> values)
        {
            this.Values = values;
            this.Columns = columns;
        }
 
        public Record this[int Index]
        {
            get
            {
                return new Record(Columns, Values[Index]);
            }
            set
            {
                Values[Index] = value.GetValues();
            }
        }
    }
}

Qu'on utilise de la sorte :

Code csharp :

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
 
using System;
using System.Collections.Generic;
 
namespace AccessorTest
{
    class Program
    {
        static void Main(string[] args)
        {
            MonDT dt = new MonDT(new List<string>(new string[] { "cle", "valeur" }), new List<List<Value>>(new List<Value>[] {
                new List<Value>(new Value[] { new Value("1"), new Value("toto") }),
                new List<Value>(new Value[] { new Value("2"), new Value("titi") }),
                new List<Value>(new Value[] { new Value("3"), new Value("tata") })
            }));
 
            Console.WriteLine(dt[1]["valeur"].value);
            dt[1]["valeur"] = new Value("plop");
            Console.WriteLine(dt[1]["valeur"].value);
            Console.ReadKey();
        }
    }
}

Je veux que lorsque je fais "dt[1]["valeur"] = new Value("plop");" je puisse déclencher une méthode "Check()" de mon instance "dt".

**StringBuilder** · 30/10/2014, 16h21

Envoyé par lead8209

Ton code est confidentiel ?

Non pas du tout, c'est de la veille techno

Seulement, j'ai pas le code sous la main, donc j'ai du tout retaper en vitesse de tête

**lead8209** · 30/10/2014, 16h24

Je regarde. Je te tiens au jus demain matin.

**StringBuilder** · 30/10/2014, 16h35

GRMPF !

Code csharp :

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
using System;
using System.Collections.Generic;
 
namespace AccessorTest
{
    public class Value
    {
        public string value = string.Empty;
 
        public Value(string value)
        {
            this.value = value;
        }
    }
 
    public class Record
    {
        public delegate void ChangedEvent(Record changedRecord);
        public event ChangedEvent changed;
 
        private List<string> Columns;
        private List<Value> Values;
 
        public Record(List<string> columns, List<Value> values)
        {
            this.Columns = columns;
            this.Values = values;
        }
 
        public Value this[int Index]
        {
            get
            {
                return Values[Index];
            }
            set
            {
                Values[Index] = value;
                OnChanged();
            }
        }
 
        public Value this[string Column]
        {
            get
            {
                for (int i = 0, cpt = Columns.Count; i < cpt; i++)
                {
                    if (Columns[i] ==  Column)
                    {
                        return Values[i];
                    }
                }
                throw new KeyNotFoundException();
            }
            set
            {
                for (int i = 0, cpt = Columns.Count; i < cpt; i++)
                {
                    if (Columns[i] ==  Column)
                    {
                        Values[i] = value;
                        OnChanged();
                        break;
                    }
                }
            }
        }
 
        public List<Value> GetValues()
        {
            return Values;
        }
 
        protected virtual void OnChanged()
        {
            if (changed != null)
            {
                changed(this);
            }
        }
    }
 
    public class MonDT
    {
        private List<List<Value>> Values;
        private List<string> Columns;
 
        public MonDT(List<string> columns, List<List<Value>> values)
        {
            this.Values = values;
            this.Columns = columns;
        }
 
        private void Check(Record rec)
        {
            Console.WriteLine("Check!!!");
        }
 
        public Record this[int Index]
        {
            get
            {
                Record res = new Record(Columns, Values[Index]);
                res.changed += new Record.ChangedEvent(Check);
                return res;
            }
            set
            {
                Values[Index] = value.GetValues();
            }
        }
    }
}

En fait, il suffit de m'abonner à un événement de nom nouveau Record, même s'il n'a comme durée de vie que celle de l'affectation de la nouvelle valeur.

Et ça marche.

Par contre, je ne peux pas me désabonner ensuite. C'est grave ? Etant donné que Record est déduit dès la ligne suivante ?

**lead8209** · 30/10/2014, 16h40

Bon nickel si tu as trouvé.
Moi j'étais parti sur le contrôle de Value plutôt. Mais après ça dépend vraiment de ce que tu veux faire :

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
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
147
 
class Program
    {
        static void Main(string[] args)
        {
             MonDT dt = new MonDT(new List<string>(new string[] { "cle", "valeur" }), new List<List<Value>>(new List<Value>[] {
                new List<Value>(new Value[] { new Value("1"), new Value("toto") }),
                new List<Value>(new Value[] { new Value("2"), new Value("titi") }),
                new List<Value>(new Value[] { new Value("3"), new Value("tata") })
            }));
 
 
            Console.WriteLine(dt[1]["valeur"].value);
            dt[1]["valeur"].value = "plop";
            Console.WriteLine(dt[1]["valeur"].value);
            Console.ReadKey();
        }
    }
 
    public class Value
    {
        private string _value = string.Empty;
        public string value
        {
            get
            {
                return _value;
            }
            set
            {
                _value = value;
                OnChanged();
            }
        }
 
        public delegate void ChangedEvent(Value pItem);
        public event ChangedEvent changed;
 
        protected virtual void OnChanged()
        {
            if (changed != null)
            {
                changed(this);
            }
        }
 
        public Value(string value)
        {
            this.value = value;
        }
    }
 
    public class Record
    {
        private List<string> Columns;
        private List<Value> Values;
 
        public Record(List<string> columns, List<Value> values)
        {
            this.Columns = columns;
            this.Values = values;
        }
 
        public Value this[int Index]
        {
            get
            {
                return Values[Index];
            }
            set
            {
                Values[Index] = value;
            }
        }
 
        public Value this[string Column]
        {
            get
            {
                for (int i = 0, cpt = Columns.Count; i < cpt; i++)
                {
                    if (Columns[i] == Column)
                    {
                        return Values[i];
                    }
                }
                throw new KeyNotFoundException();
            }
            set
            {
                for (int i = 0, cpt = Columns.Count; i < cpt; i++)
                {
                    if (Columns[i] == Column)
                    {
                        Values[i] = value;
                        break;
                    }
                }
            }
        }
 
        public List<Value> GetValues()
        {
            return Values;
        }
    }
 
    public class MonDT
    {
        private List<List<Value>> Values;
        private List<string> Columns;
 
        public MonDT(List<string> columns, List<List<Value>> values)
        {
            this.Values = values;
            foreach (var lvalues in this.Values)
            {
                foreach (var value in lvalues)
                {
                    value.changed += new Value.ChangedEvent(Check);
                }
            }
            this.Columns = columns;
        }
 
        public Record this[int Index]
        {
            get
            {
                return new Record(Columns, Values[Index]);
            }
            set
            {
                Values[Index] = value.GetValues();
            }
        }
 
 
        void Check(Value pItem)
        {
            Console.WriteLine("value changed !");
            foreach (var ligne in Values)
            {
                //check here
            }
        }
    }

Pour le désabonnement je ne sais pas. Faut demander aux gourous .Net. A première vue je dirais non.
Aussi pourquoi ne pas utiliser une DataTable directement ?
Je vois pas bien aussi pour le new Value("") ? pourquoi ne pas réassigner la valeur de ta propriété plutôt que de recréer un nouvel objet ?

**lead8209** · 30/10/2014, 16h45

Hmmm peut être pas terrible finalement :

Annulez un abonnement à l'événement pour empêcher votre gestionnaire d'événements d'être appelé lorsque l'événement est déclenché. Pour empêcher toute fuite de ressources, vous devez annuler un abonnement aux événements avant d'éliminer un objet d'abonné. Tant que vous n'avez pas annulé l'abonnement à un événement, le délégué multicast sous-jacent à l'événement de l'objet d'édition possède une référence au délégué qui encapsule le gestionnaire d'événements de l'abonné. Tant que l'objet de l'édition détient cette référence, le garbage collection ne supprimera pas votre objet d'abonné.

cf : http://msdn.microsoft.com/fr-fr/library/ms366768.aspx

Mais tu m'enlèveras pas de la tête que ta structure de données est trop compliquée pour ce que tu veux stocker

**StringBuilder** · 30/10/2014, 17h01

J'ai l'impression que ta citation, c'est le cas inverse : il faut désabonner "dt" de tous les Record avant de détruire "dt", sinon un "changed" sur les Record toujours existant va tenté d'appeler une delegate qui n'existe plus.

Pour l'autre sens, je me demande si c'est nécessaire (automatique ?).

Sinon, Value est en réalité une interface.
Mes valeurs peuvent avoir des types divers et variés implémentant l'interface, donc je ne peux pas me contenter de changer une propriété ".value"

Sinon, je ne veux pas utiliser un datatable car je veux maîtriser le fonctionnement et le poids de mon objet, ce qui n'est pas possible avec une classe déjà toute faite. Et en hériter pour l'enrichir, pas une bonne idée non plus, ça ne va faire qu'alourdir les choses.

Sinon, en quoi mon truc est lourd ?

Certes, ok, le faite d'instancier un Record au lieu de retourner directement un List<Value> n'est pas forcément la meilleure chose qui soit. Cependant, il n'y a aucune copie de données, uniquement des références, donc rien de bien lourd...

**lead8209** · 30/10/2014, 17h15

Oui tu as peut-être raison pour le désabonnement.

Pour le reste c'est juste qu'à voir un code aussi généraliste on comprend pas forcément l'imbrication des données.
Même sans parler de Datatable qui est lourd, c'est sûr; Tu fais une classe DATA dans laquelle tu as une List<Value[]> pour gérer les lignes + valeurs, une List<string> pour les colonnes et t'as grossomodo une datatable légère.
Deux trois méthodes qui te lancent les bons événements sur Add, Remove, Modify et tu peux gérer ton unicité de ligne et tes modifications.
Sur l'utilité aussi que les lignes connaissent les colonnes c'est à voir...
Enfin sans connaitre le but final on peut discuter longtemps. L'essentiel c'est que tu sois arrivé à faire ton truc ^^

**StringBuilder** · 30/10/2014, 17h31

Bah c'est bien ce que j'ai fait.

Au détail près que je veux pouvoir récupérer les colonnes avec les valeurs d'une ligne.
En effet, je veux ensuite être capable de sérialiser les données, et cela dépend des colonnes (c'est pas de simple string, mais des objets à part entière).

En revanche, je suis en train de me demander si on peut aussi faire des indexeur qui acceptent plusieurs paramètres... J'imagine que oui.

Comme ça je pourrai aussi modifier directement les données d'une ligne/colonne avec un simple dt[1, "macolonne"] = new Value() ce qui devrait être plus léger...