ObservableCollection <> vs List <>
J'ai beaucoup d'entités avec List<> Imbriquées dans chacune.
Par exemple, j'ai BaseEntity qui a List<ColumnEntity>. ColumnEntity classe a List<Info> et ainsi de suite.
Nous travaillons avec une interface utilisateur WPF , et nous devons suivre toutes les modifications dans chaque liste de BaseEntity. Il est implémenté en instanciant un new ObservableCollection Basé sur la liste requise, et en le liant à ce ObservableCollection.
Quels sont les avantages et les inconvénients de changer tous ces Lists imbriqués en ObservableCollections? Nous pouvons donc suivre toutes les modifications dans BaseEntity lui-même sans réaffecter chaque liste de BaseEntity à la borne modifiée ObservableCollection?
En supposant que les méthodes spécifiques à List ne sont jamais utilisées.
Question intéressante, étant donné que List et ObservableCollection implémentent IList<T> il n'y a pas beaucoup de différence, ObservableCollection implémente également l'interface INotifyCollectionChanged, qui permet à WPF de s'y lier.
L'une des principales différences est que ObservableCollection n'a pas de méthode AddRange, ce qui peut avoir des implications.
De plus, je n'utiliserais pas ObservableCollection pour les endroits où je sais que je ne serais pas lié, pour cette raison, il est important de passer en revue votre conception et de vous assurer que vous adoptez la bonne approche pour séparer les couches de préoccupation.
En ce qui concerne les différences entre Collection<T> et List<T> vous pouvez jeter un oeil ici Listes génériques vs Collection
Cela dépend exactement de ce que vous entendez par ceci:
nous devons suivre toutes les modifications dans chaque liste de BaseEntity
Serait-il suffisant de suivre les modifications apportées aux objets déjà dans la liste? Ou avez-vous besoin de savoir quand des objets sont supprimés de/sont ajoutés à/changent de position dans la liste?
Si une liste contient les mêmes éléments pour toute leur durée de vie, mais que les objets individuels de cette liste vont changer, il suffit que les objets lèvent des notifications de changement (généralement via INotifyPropertyChanged) et List<T> est suffisant. Mais si la liste contient de temps en temps différents objets ou si l'ordre change, vous devez utiliser ObservableCollection<T>.
Ainsi, même si les différences peuvent être intéressantes (et qu'une affiche précédente les a déjà couvertes), vous n'aurez généralement pas le choix - soit vous avez besoin de ObservableCollection<T> ou non.
La liste représente une liste fortement typée d'objets accessibles par index. Il fournit des méthodes pour rechercher, trier et manipuler des listes. La classe List est l'équivalent générique de la classe ArrayList. Il implémente l'interface générique IList à l'aide d'un tableau dont la taille est augmentée dynamiquement selon les besoins.
ObservableCollection est une collection de données dynamiques génériques qui utilise une interface "INotifyCollectionChanged" pour fournir des notifications lorsque des éléments sont ajoutés, supprimés ou lorsque la collection entière est actualisée.
En savoir plus à ce sujet dans ce lien: http://www.codeproject.com/Articles/42536/List-vs-ObservableCollection-vs-INotifyPropertyCha
Une différence plus importante est que vous ne pouvez accéder à ObservableCollection qu'à partir du thread sur lequel il a été créé et où la liste est accessible à partir de n'importe quel thread.
Je ne vois aucun problème à cela, à part une surcharge de performances très marginale.
Notez que si vous modifiez directement les listes internes, vous n'êtes pas informé des modifications. De plus, si les objets contenus dans ObservableCollection sont modifiés, vous n'en êtes pas averti. La notification ne se produit que si des éléments sont ajoutés, remplacés, supprimés ou déplacés.