Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter
IDictionary et binding bidirectionel
Bonjour,
J'aimerais binder une SortedList<int, string> (ou une classe dérivée) à une combobox de manière à ce que les valeurs de ma SortedList soient affiché dans la combox dans l'ordre des clés. Il faudrait également que tout changement effectué dans ma SortedList soit répercuté automatiquement dans ma combobox.
Auriez-vous une idée pour concrétiser cela ?
Salut,
Je pense que ça ne marchera pas avec le BindingSource parce qu'il faut remettre à jour la DataSource lors du changement de la dictionary.
Regarde de coté de l'Interface INotifyPropertyChanged, peut être que tu trouvera ton bonheure
Implémenter INotifyPropertyChanged ne suffit pas pour que mon contrôle soit automatiquement mis à jour quand la datasource change. Il faut implémenter IBindingList.
Cependant, j'ai put écrire ceci :
En intercalant NotifySource<T> entre la datasource de mon contrôle et ma liste implémentant INotifyList<T>, le contrôle sera alors automatiquement mis à jour lorsque cette dernière changera.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256public interface INotifyList<T> : INotifyCollectionChanged, IList<T> { } public class NotifySource<T> : ITypedList, IBindingList { protected INotifyList<T> dataSource = null; private INotifyList<T> internalList; public INotifyList<T> InternalList { get { return internalList; } set { internalList = value; internalList.CollectionChanged += new NotifyCollectionChangedEventHandler(internalList_CollectionChanged); } } void internalList_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { if (ListChanged != null) { ListChangedType t; if(e.NewItems.Count!=0) t = ListChangedType.ItemAdded; else if (e.OldItems.Count!=0) t = ListChangedType.ItemDeleted; else if (e.OldStartingIndex != e.NewStartingIndex) t = ListChangedType.ItemMoved; else t = ListChangedType.ItemChanged; ListChanged(this, new ListChangedEventArgs(t,e.NewStartingIndex, e.OldStartingIndex)); } } protected virtual IBindingList List { get { if (InternalList == null) InternalList = ((INotifyList<T>)ListBindingHelper.GetList(dataSource)); return new System.ComponentModel.BindingList<T>((IList<T>)InternalList); } } public INotifyList<T> DataSource { get { return dataSource; } set { dataSource = value; if (customSourceView != null) customSourceView.ResetList(); } } protected CustomSourceViewBase customSourceView = null; #region IBindingList Members public void AddIndex(PropertyDescriptor property) { List.AddIndex(property); } public object AddNew() { return List.AddNew(); } public bool AllowEdit { get { return List.AllowEdit; } } public bool AllowNew { get { return List.AllowNew; } } public bool AllowRemove { get { return List.AllowRemove; } } public void ApplySort(PropertyDescriptor property, ListSortDirection direction) { List.ApplySort(property, direction); } public int Find(PropertyDescriptor property, object key) { return List.Find(property, key); } public bool IsSorted { get { return List.IsSorted; } } public event ListChangedEventHandler ListChanged; public void RemoveIndex(PropertyDescriptor property) { List.RemoveIndex(property); } public void RemoveSort() { List.RemoveSort(); } public ListSortDirection SortDirection { get { return List.SortDirection; } } public PropertyDescriptor SortProperty { get { return List.SortProperty; } } public bool SupportsChangeNotification { get { return List.SupportsChangeNotification; } } public bool SupportsSearching { get { return List.SupportsSearching; } } public bool SupportsSorting { get { return List.SupportsSorting; } } #endregion #region ICollection Members public void CopyTo(Array array, int index) { List.CopyTo(array, index); } public bool IsSynchronized { get { return List.IsSynchronized; } } public object SyncRoot { get { return List.SyncRoot; } } public int Count { get { return List.Count; } } #endregion #region IList Members public int Add(object value) { return List.Add(value); } public void Clear() { List.Clear(); } public bool Contains(object value) { return List.Contains(value); } public int IndexOf(object value) { return List.IndexOf(value); } public void Insert(int index, object value) { List.Insert(index, value); } public bool IsFixedSize { get { return List.IsFixedSize; } } public bool IsReadOnly { get { return List.IsReadOnly; } } public void Remove(object value) { List.Remove(value); } public void RemoveAt(int index) { List.RemoveAt(index); } public object this[int index] { get { return List[index]; } set { List[index] = value; } } #endregion #region IEnumerable Members public IEnumerator GetEnumerator() { return List.GetEnumerator(); } #endregion #region ITypedList Members public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors) { PropertyDescriptorCollection sourceProps; if (dataSource == null) sourceProps = PropertyDescriptorCollection.Empty; object obj1 = ListBindingHelper.GetList(this.dataSource); sourceProps = ListBindingHelper.GetListItemProperties(obj1, listAccessors); return sourceProps; } public string GetListName(PropertyDescriptor[] listAccessors) { object obj1 = ListBindingHelper.GetList(this.dataSource); return ListBindingHelper.GetListName(obj1, listAccessors); } #endregion }
Maintenant il me reste à faire en gros la même chose mais pour les dictionary...
J'ai réussi.
Voici comment j'ai fait (si ça intéresse quelqu'un) :
- Tout d'abord j'ai crée l'interface suivante :
- J'ai ensuite dérivé SortedList<TKey, TValue> en implémentant INotifyListSource<T> :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
2
3
4
5
6
7public interface INotifyListSource<T> : INotifyCollectionChanged, IListSource<T> { } public interface IListSource<T> { bool ContainsListCollection { get; } IList<T> GetList(); }
- Enfin j'ai crée une classe AdvancedCustomNotifySource<T> qui s'insère entre la CsutomSortedList et la datasource du control. Cette classe implémente IBindinList. Elle récupère les valeurs de la CsutomSortedList et les insère dans une bindingList . Tous changements de la datasource déclanche l'évenement ListChanged de AdvancedCustomNotifySource<T> et notifie ainsi les changements au contrôle auquel elle est bindé. Pour cela la datasource (c.a.d ma CustomSortedList) doit implémenter INotifyListSource<T>.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
118public class CsutomSortedList<TKey, TValue> : SortedList<TKey, TValue>, INotifyListSource<TValue> { private KeyValuePair<TKey, TValue> GetPair(TKey key) { foreach (KeyValuePair<TKey, TValue> pair in this) if (pair.Key.Equals(key)) return pair; return new KeyValuePair<TKey,TValue>(key, default(TValue)); } public new void Add(TKey key, TValue value) { base.Add(key, value); this.OnItemAdded(GetPair(key)); } public new void Clear() { base.Clear(); this.OnCollectionReset(); } public new bool Remove(TKey key) { int index = this.IndexOfKey(key); bool result = base.Remove(key); this.OnItemRemoved(GetPair(key), index); return result; } public new void RemoveAt(int index) { var item = GetPair(Keys[index]); base.RemoveAt(index); this.OnItemRemoved(item, index); } #region INotifyCollectionChanged Members public event NotifyCollectionChangedEventHandler CollectionChanged; /// <summary> /// Fires the <see cref="CollectionChanged"/> event to indicate an item has been /// added to the end of the collection. /// </summary> /// <param name="item">Item added to the collection.</param> protected void OnItemAdded(KeyValuePair<TKey, TValue> item) { if (this.CollectionChanged != null) { this.CollectionChanged(this, new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, item, this.Count - 1)); } } /// <summary> /// Fires the <see cref="CollectionChanged"/> event to indicate the collection /// has been reset. This is used when the collection has been cleared or /// entirely replaced. /// </summary> protected void OnCollectionReset() { if (this.CollectionChanged != null) { this.CollectionChanged(this, new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset)); } } /// <summary> /// Fires the <see cref="CollectionChanged"/> event to indicate an item has /// been inserted into the collection at the specified index. /// </summary> /// <param name="index">Index the item has been inserted at.</param> /// <param name="item">Item inserted into the collection.</param> protected void OnItemInserted(int index, KeyValuePair<TKey, TValue> item) { if (this.CollectionChanged != null) { this.CollectionChanged(this, new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, item, index)); } } /// <summary> /// Fires the <see cref="CollectionChanged"/> event to indicate an item has /// been removed from the collection at the specified index. /// </summary> /// <param name="item">Item removed from the collection.</param> /// <param name="index">Index the item has been removed from.</param> protected void OnItemRemoved(KeyValuePair<TKey, TValue> item, int index) { if (this.CollectionChanged != null) { this.CollectionChanged(this, new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Remove, item, index)); } } #endregion #region IListSource Members public bool ContainsListCollection { get { return false; } } public IList<TValue> GetList() { return Values; } #endregion }
Bon le code est un peu long à lire à cause des longues implémentations d'interfaces, mais ça marche bien.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273public class AdvancedCustomNotifySource<T> : CustomBindingSourceBase { protected INotifyListSource<T> dataSource = null; private IList<T> internalList; public IList<T> InternalList { get { return internalList; } set { internalList = value; } } protected override IBindingList List { get { if (InternalList == null) InternalList = ((IList<T>)ListBindingHelper<T>.GetList(dataSource)); return new System.ComponentModel.BindingList<T>((IList<T>)InternalList); } } public INotifyListSource<T> DataSource { get { return dataSource; } set { dataSource = value; dataSource.CollectionChanged += new NotifyCollectionChangedEventHandler(dataSource_CollectionChanged); } } void dataSource_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { ListChangedType t; if (e.NewItems.Count != 0) t = ListChangedType.ItemAdded; else if (e.OldItems.Count != 0) t = ListChangedType.ItemDeleted; else if (e.OldStartingIndex != e.NewStartingIndex) t = ListChangedType.ItemMoved; else t = ListChangedType.ItemChanged; OnListChanged(this, new ListChangedEventArgs(t, e.NewStartingIndex, e.OldStartingIndex)); } #region ITypedList Members public override PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors) { PropertyDescriptorCollection sourceProps; if (dataSource == null) sourceProps = PropertyDescriptorCollection.Empty; object obj1 = ListBindingHelper.GetList(this.dataSource); sourceProps = ListBindingHelper.GetListItemProperties(obj1, listAccessors); return sourceProps; } public override string GetListName(PropertyDescriptor[] listAccessors) { object obj1 = ListBindingHelper.GetList(this.dataSource); return ListBindingHelper.GetListName(obj1, listAccessors); } #endregion } public static class ListBindingHelper<T> { public static object GetList(object list) { if (list is IListSource<T>) return ((IListSource<T>)list).GetList(); return ListBindingHelper.GetList(list); } } public abstract class CustomBindingSourceBase : IBindingList, ITypedList { protected abstract IBindingList List { get; } protected void OnListChanged(object sender, ListChangedEventArgs e) { if (ListChanged != null) ListChanged(sender, e); } #region IBindingList Members public void AddIndex(PropertyDescriptor property) { List.AddIndex(property); } public object AddNew() { return List.AddNew(); } public bool AllowEdit { get { return List.AllowEdit; } } public bool AllowNew { get { return List.AllowNew; } } public bool AllowRemove { get { return List.AllowRemove; } } public void ApplySort(PropertyDescriptor property, ListSortDirection direction) { List.ApplySort(property, direction); } public int Find(PropertyDescriptor property, object key) { return List.Find(property, key); } public bool IsSorted { get { return List.IsSorted; } } public event ListChangedEventHandler ListChanged; public void RemoveIndex(PropertyDescriptor property) { List.RemoveIndex(property); } public void RemoveSort() { List.RemoveSort(); } public ListSortDirection SortDirection { get { return List.SortDirection; } } public PropertyDescriptor SortProperty { get { return List.SortProperty; } } public bool SupportsChangeNotification { get { return List.SupportsChangeNotification; } } public bool SupportsSearching { get { return List.SupportsSearching; } } public bool SupportsSorting { get { return List.SupportsSorting; } } #endregion #region ICollection Members public void CopyTo(Array array, int index) { List.CopyTo(array, index); } public bool IsSynchronized { get { return List.IsSynchronized; } } public object SyncRoot { get { return List.SyncRoot; } } public int Count { get { return List.Count; } } #endregion #region IList Members public int Add(object value) { return List.Add(value); } public void Clear() { List.Clear(); } public bool Contains(object value) { return List.Contains(value); } public int IndexOf(object value) { return List.IndexOf(value); } public void Insert(int index, object value) { List.Insert(index, value); } public bool IsFixedSize { get { return List.IsFixedSize; } } public bool IsReadOnly { get { return List.IsReadOnly; } } public void Remove(object value) { List.Remove(value); } public void RemoveAt(int index) { List.RemoveAt(index); } public object this[int index] { get { return List[index]; } set { List[index] = value; } } #endregion #region IEnumerable Members public IEnumerator GetEnumerator() { return List.GetEnumerator(); } #endregion #region ITypedList Members public abstract PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors); public abstract string GetListName(PropertyDescriptor[] listAccessors); #endregion }
Pk ne pas avoir fait une class qui hérite de list et de INotifyPropertyChanged ?
Chaque changement de ta list va déclanger ListChanged et tu as juste a mettre rafraichir ton binding dans ton handler
Ma classe hérite déjà de SortedList.Pk ne pas avoir fait une class qui hérite de list et de INotifyPropertyChanged ?
Je ne comprends pas. Pourrais-tu donner un petit exemple ?tu as juste a mettre rafraichir ton binding dans ton handler
Implémenter INotifyPropertyChanged suffit à faire qu'une modification de ma collection sera automatiquement répercutée dans le contrôle auquel elle est bindé ? Je sais que ce n'est pas le cas avec INotifyCollectionChanged. Mais ça marche avec IBindingList.
Répondre avec citation
Partager