Bonjour,
J'ai un problème un peu compliqué concernant le databinding. Je cherche
à faire une classe qui servira d'intermédiaire entre la propriété
Datasource d'un contrôle et la collection auquel celui-ci est bindé. Je
vais ici donner un exemple d'une classe qui ne sert à rien mais qui à
le mérite de simplifier aux maximum les choses tout en montrant mon
problème. L'exemple reste un peu long à cause de l'implémentation de
IBindingList dans SourceView<T> mais est facilement lisible.
Voici mon problème :
J'intercale une instance de Source<string> entre une listbox et
une collection BindingList<string>. Je souhaite être notifié des
changements quand je modifie la collection BindingList<string>.
Pour vérifier cela, je supprime un élément de cette collection et je
regarde si le contrôle est mis à jour.
Le problème est que mon contrôle n'est pas mis à jour dans mon exemple
ci dessous. En revanche, si je modifie la propriété List de la classe
SourceView<T> pour qu'elle soit réévaluée à chaque fois comme
ceci :
Code :
public IBindingList List
{
get
{
DataSource.ListChanged += new ListChangedEventHandler(List_ListChanged);
returnnew BindingList<T>(new List<T>((IEnumerable<T>) DataSource));
}
set{ _List = value; }
}
alors mon contrôle est bien mis à
jour. J'ai d'ailleurs remarqué que c'est la propriété AllowNew
(renvoyant List.AllowNew) qui pose le problème. Au moment du Binding,
elle est appelé plusieurs fois et si List n'est pas réévaluée à chaque
appel alors le contrôle n'est plus notifié des changements de la
datasource. Sauriez-vous m'expliquer pourquoi ?
Voici l'exemple complet.
Code :
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
privatevoid Form1_Load(object sender, EventArgs e)
{
BindingList<string> s = new BindingList<string> {"aaa", "bbb", "ccc"};
Source<string> source = new Source<string>();
source.DataSource = s;
listBox1.DataSource = source;
s.RemoveAt(1);
}
}
publicclass Source<T> : IListSource
{
public IBindingList DataSource {get; set; }
#region IListSource Members
publicbool ContainsListCollection
{
get{returntrue; }
}
public System.Collections.IList GetList()
{
returnnew SourceView<T>(DataSource);
}
#endregion
}
publicclass SourceView<T> : IBindingList
{
public IBindingList DataSource {get; set; }
private IBindingList _List;
public IBindingList List
{
get
{
if(_List == null)
{
DataSource.ListChanged += new ListChangedEventHandler(List_ListChanged);
_List = new BindingList<T>(new List<T>((IEnumerable<T>) DataSource));
}
return _List;
}
set{ _List = value; }
}
public SourceView(IBindingList datasource)
{
DataSource = datasource;
}
void List_ListChanged(object sender, ListChangedEventArgs e)
{
if(ListChanged != null)
ListChanged(this, e);
}
#region IBindingList Members
publicvoid AddIndex(PropertyDescriptor property)
{
List.AddIndex(property);
}
publicobject AddNew()
{
return List.AddNew();
}
publicbool AllowEdit
{
get{return List.AllowEdit; }
}
publicbool AllowNew
{
get{return List.AllowNew; }
}
publicbool AllowRemove
{
get{return List.AllowRemove; }
}
publicvoid ApplySort(PropertyDescriptor property, ListSortDirection direction)
{
List.ApplySort(property, direction);
}
publicint Find(PropertyDescriptor property, object key)
{
return List.Find(property, key);
}
publicbool IsSorted
{
get{return List.IsSorted; }
}
publicevent ListChangedEventHandler ListChanged;
publicvoid RemoveIndex(PropertyDescriptor property)
{
List.RemoveIndex(property);
}
publicvoid RemoveSort()
{
List.RemoveSort();
}
public ListSortDirection SortDirection
{
get{return List.SortDirection; }
}
public PropertyDescriptor SortProperty
{
get{return List.SortProperty; }
}
publicbool SupportsChangeNotification
{
get{return List.SupportsChangeNotification; }
}
publicbool SupportsSearching
{
get{return List.SupportsSearching; }
}
publicbool SupportsSorting
{
get{return List.SupportsSorting; }
}
#endregion
#region IList Members
publicvirtualint Add(object value)
{
return List.Add(value);
}
publicvirtualvoid Clear()
{
List.Clear();
}
bool IList.Contains(object value)
{
return List.Contains(value);
}
publicvirtualint IndexOf(object value)
{
return List.IndexOf(value);
}
publicvirtualvoid Insert(int index, object value)
{
List.Insert(index, value);
}
bool IList.IsFixedSize
{
get
{
return List.IsFixedSize;
}
}
bool IList.IsReadOnly
{
get
{
return List.IsReadOnly;
}
}
publicvirtualvoid Remove(object value)
{
List.Remove(value);
}
publicvirtualvoid RemoveAt(int index)
{
List.RemoveAt(index);
}
publicobjectthis[int index]
{
get{return List[index]; }
set{ List[index] = value;}
}
#endregion
#region ICollection Members
void ICollection.CopyTo(Array array, int index)
{
List.CopyTo(array, index);
}
publicint Count
{
get{return List.Count; }
}
bool ICollection.IsSynchronized
{
get
{
return List.IsSynchronized;
}
}
object ICollection.SyncRoot
{
get
{
return List.SyncRoot;
}
}
#endregion
#region IEnumerable Members
public IEnumerator GetEnumerator()
{
return List.GetEnumerator();
}
#endregion
}
merci d'avance pour votre aide.
Mathmax
****************************************
