\r\npublic<\/span> class<\/span> SingleViewModel \r\n{\r\n ObservableCollection<ItemViewModel> _items;\r\n public<\/span> ObservableCollection<ItemViewModel> Items\r\n {\r\n get<\/span> { return<\/span> _items ?? (_items = CollectionCreator.CreateItems(200)); } \r\n }\r\n public<\/span> ItemViewModel SelectedItem { get<\/span>; set<\/span>; }\r\n}\r\n<\/pre>\nEin Eintrag in der OberservableCollection ist wiederum ein ViewModel. Es besteht nur aus dem Property Name:<\/p>\n
\r\npublic<\/span> class<\/span> ItemViewModel\r\n{\r\n public<\/span> ItemViewModel(string<\/span> name)\r\n {\r\n Name = name;\r\n }\r\n public<\/span> string<\/span> Name { get<\/span>; private<\/span> set<\/span>; }\r\n}\r\n<\/pre>\nDie View stellt zu Demonstrationszwecken das ausgew\u00e4hlte Element der ListBox als Text dar. <\/p>\n
\r\n<<\/span>DockPanel<\/span> DataContext<\/span>=\"{StaticResource ViewModel}\"<\/span>><\/span>\r\n <<\/span>TextBlock<\/span> DockPanel<\/span>.Dock<\/span>=\"Bottom\"<\/span> \r\n Text<\/span>=\"{Binding SelectedItem.Name}\"<\/span> \r\n Height<\/span>=\"25\"<\/span>\/><\/span>\r\n <<\/span>ListBox<\/span> ItemsSource<\/span>=\"{Binding Items}\"<\/span> \r\n DisplayMemberPath<\/span>=\"Name\"<\/span>\r\n SelectedItem<\/span>=\"{Binding SelectedItem}\"<\/span> \/><\/span>\r\n<\/<\/span>DockPanel<\/span>><\/span>\r\n<\/pre>\nNachdem wir dem Datenkontext der View eine Instanz seines SingleViewModels zugewiesen haben, sehen wir, dass der Zugriff auf die aktuelle Selektion auf diese Weise bereits funktioniert.<\/p>\n
![\"Beispiel:](\"https:\/\/www.centigrade.de\/wordpress\/wp-content\/uploads\/ListViewSelectionSample.png\")
<\/p>\n
Selektion innerhalb einer TreeView<\/h2>\n
Das bisherige Beispiel bedient sich einer einfachen Liste. Was aber, wenn unsere Daten in einer zweistufigen Hierarchie ohne Gruppierung vorliegen? F\u00fcr diesen Fall erweitern wir unser ItemViewModel um ein umschlie\u00dfendes NodeViewModel:<\/p>\n
\r\npublic<\/span> class<\/span> NodeViewModel\r\n{\r\n public<\/span> NodeViewModel(string<\/span> name)\r\n {\r\n Name = name;\r\n }\r\n \r\n public<\/span> string<\/span> Name { get<\/span>; internal<\/span> set<\/span>; }\r\n public<\/span> ObservableCollection<ItemViewModel> Leafs { get<\/span>; set<\/span>; }\r\n}\r\n<\/pre>\nWir erweitern das ViewModel unserer TreeView um eine zweite Selektionsm\u00f6glichkeit:<\/p>\n
\r\npublic<\/span> class<\/span> TreeViewModel \r\n{\r\n ObservableCollection<NodeViewModel> _nodes;\r\n public<\/span> ObservableCollection<NodeViewModel> Nodes\r\n {\r\n get<\/span> { return<\/span> _nodes ?? (_nodes = CollectionCreator.CreateNodes(100, 5)); }\r\n }\r\n \r\n public<\/span> NodeViewModel SelectedNode { get<\/span>; set<\/span>; }\r\n public<\/span> ItemViewModel SelectedLeaf { get<\/span>; set<\/span>; }\r\n \r\n object<\/span> _selectedItem;\r\n public<\/span> object<\/span> SelectedItem\r\n {\r\n get<\/span> { return<\/span> _selectedItem; }\r\n set<\/span>\r\n {\r\n SelectedLeaf = value as<\/span> ItemViewModel;\r\n SelectedNode = value as<\/span> NodeViewModel;\r\n }\r\n }\r\n}\r\n<\/pre>\nBeim Versuch, den selektierten Eintrag einfach per Bindung zu setzen, werden wir herb entt\u00e4uscht: das Property SelectedItem ist schreibgesch\u00fctzt und kann nicht ge\u00e4ndert werden. Durchsuchen wir das Internet nach diesem Problem, finden wir den Hinweis, das IsSelected-Property eines jeden TreeViewItems auf ein entsprechendes Property im jeweils zugeh\u00f6rigen NodeViewModel abzubilden. Hiervon ist jedoch aus mehreren Gr\u00fcnden abzuraten:<\/p>\n
\n- Falls ein Command von dieser Selektion abh\u00e4ngig ist und sein CanExecute auf einen SelectionChangedEvent reagieren soll, m\u00fcssten alle Items dem ViewModel eine \u00c4nderung ihres Status mitteilen.\n <\/li>\n
- Die Selektionseigenschaft sollte schon konzeptuell nicht am Item h\u00e4ngen. Dies verbietet es mitunter, zwei Listen mit identischen Item-ViewModels zu f\u00fcllen, die Selektionen jedoch separat zu halten, wie dies beispielsweise in einer Implementierung des List-Builder Patterns<\/a> sinnvoll sein kann.\n <\/li>\n
- Wie man weiter unten bei der Mehrfachselektion selbst probieren kann, zerst\u00f6rt man entweder die Virtualisierung<\/a> der Liste, was zu enormen Performance-Einbu\u00dfen f\u00fchren kann, oder man erh\u00e4lt unzuverl\u00e4ssige Ergebnisse. Beispielsweise werden bei einem SelectAll-Kommando die ersten 20 Items als selektiert gemeldet, obwohl die Liste 100 Items beinhaltet. Erst beim Herunterscrollen werden wirklich alle Items als selektiert gemeldet. Der Grund ist, dass die \u00fcbrigen 80 Items aufgrund der Virtualisierung ja noch gar nicht instanziiert worden sind, die Bindings an das IsSelected-Property demnach auch noch gar nicht etabliert worden sind.\n <\/li>\n<\/ul>\n
Man kann<\/em> durchaus diese M\u00f6glichkeit w\u00e4hlen, wenn man sich der Konsequenzen bewusst ist. Allerdings ist die Alternativm\u00f6glichkeit gar nicht so kompliziert: man implementiert ein Behavior, welches sich um die Synchronisation des Selektionsstatus der TreeViewItems k\u00fcmmert und zwischen TreeView und deren ViewModel vermittelt, statt auf ein direktes Binding zur\u00fcckzugreifen. <\/p>\nEinziger Nachteil ist eine zus\u00e4tzliche Abh\u00e4ngigkeit zur Assembly System.Windows.Interactivity.dll.<\/p>\n
Im XAML Code selbst werden f\u00fcr diesen Ansatz lediglich 3 zus\u00e4tzliche Zeilen ben\u00f6tigt:<\/p>\n
\r\n<<\/span>DockPanel<\/span> DataContext<\/span>=\"{StaticResource ViewModel}\"<\/span>><\/span>\r\n <<\/span>StackPanel<\/span> DockPanel<\/span>.Dock<\/span>=\"Bottom\"<\/span> Orientation<\/span>=\"Horizontal\"<\/span> Height<\/span>=\"25\"<\/span>><\/span>\r\n <<\/span>TextBlock<\/span> Text<\/span>=\"{Binding SelectedNode.Name}\"<\/span> \/><\/span>\r\n <<\/span>TextBlock<\/span> Text<\/span>=\"{Binding SelectedLeaf.Name}\"<\/span> \/><\/span>\r\n <\/<\/span>StackPanel<\/span>><\/span>\r\n <<\/span>TreeView<\/span> ItemsSource<\/span>=\"{Binding Nodes}\"<\/span>><\/span>\r\n <<\/span>TreeView.ItemTemplate<\/span>><\/span>\r\n <<\/span>HierarchicalDataTemplate<\/span> ItemsSource<\/span>=\"{Binding Leafs}\"<\/span>><\/span>\r\n <<\/span>TextBlock<\/span> Text<\/span>=\"{Binding Path=Name}\"<\/span> \/><\/span>\r\n <\/<\/span>HierarchicalDataTemplate<\/span>><\/span> \r\n <\/<\/span>TreeView.ItemTemplate<\/span>><\/span>\r\n <<\/span>i:Interaction.Behaviors<\/span>><\/span>\r\n <<\/span>behaviors:SelectedItemBehavior<\/span> SelectedItem<\/span>=\"{Binding SelectedItem}\"<\/span> \/><\/span>\r\n <\/<\/span>i:Interaction.Behaviors<\/span>><\/span>\r\n <\/<\/span>TreeView<\/span>><\/span>\r\n<\/<\/span>DockPanel<\/span>><\/span>\r\n<\/pre>\nDas Behavior selbst registriert lediglich das DependencyProperty SelectedItem und registriert sich selbst auf die \u00c4nderungen des selektierten Items der TreeView. Der entsprechende Event-Handler k\u00fcmmert sich darum, das selektierte Item zwischen TreeView und TreeViewModel zu synchronisieren:<\/p>\n
\r\npublic<\/span> class<\/span> SelectedItemBehavior : Behavior<TreeView>\r\n{\r\n public<\/span> static<\/span> readonly<\/span> DependencyProperty SelectedItemProperty =\r\n DependencyProperty.Register(\"SelectedItem\"<\/span>\r\n , typeof<\/span>(object<\/span>)\r\n , typeof<\/span>(SelectedItemBehavior)\r\n , new<\/span> FrameworkPropertyMetadata(null<\/span>, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSelectedItemChanged));\r\n \r\n static<\/span> void<\/span> OnSelectedItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)\r\n {\r\n var<\/span> item = e.NewValue as<\/span> TreeViewItem;\r\n if<\/span> (item != null<\/span>)\r\n item.SetValue(TreeViewItem.IsSelectedProperty, true<\/span>);\r\n }\r\n \r\n public<\/span> object<\/span> SelectedItem\r\n {\r\n get<\/span> { return<\/span> (object<\/span>)GetValue(SelectedItemProperty); }\r\n set<\/span> { SetValue(SelectedItemProperty, value); }\r\n }\r\n \r\n protected<\/span> override<\/span> void<\/span> OnAttached()\r\n {\r\n base<\/span>.OnAttached();\r\n AssociatedObject.SelectedItemChanged += OnTreeViewSelectedItemChanged;\r\n }\r\n \r\n protected<\/span> override<\/span> void<\/span> OnDetaching()\r\n {\r\n base<\/span>.OnDetaching();\r\n if<\/span> (AssociatedObject != null<\/span>)\r\n {\r\n AssociatedObject.SelectedItemChanged -= OnTreeViewSelectedItemChanged;\r\n }\r\n }\r\n \r\n void<\/span> OnTreeViewSelectedItemChanged(object<\/span> sender, RoutedPropertyChangedEventArgs<object<\/span>> e)\r\n {\r\n SelectedItem = e.NewValue;\r\n }\r\n}\r\n<\/pre>\nWir sehen, je nach Art des selektierten Items, den entsprechenden Text in der Fu\u00dfzeile:<\/p>\n
![\"Beispiel:](\"https:\/\/www.centigrade.de\/wordpress\/wp-content\/uploads\/TreeViewSelectionSample.png\")
<\/p>\n
Mehrfachselektion<\/h2>\n
Wir konnten bereits bei Einfachselektionen eine Redundanz bei der Haltung von Selektionsinformationen feststellen \u2013 dieser Nachteil f\u00e4llt bei Mehrfachselektionen noch st\u00e4rker ins Gewicht. Denn bei jeder Abfrage, ob eine Selektion vorliegt, muss der Selektionsstatus jedes einzelnen Items abgefragt werden, beispielsweise durch Items.Any(x=>x.IsSelected)<\/em>. Sobald ein Kommando auf der Selektion ausgef\u00fchrt werden soll, ist wiederum eine Suche nach denjenigen Items n\u00f6tig,die als selektiert markiert wurden, beispielsweise mittels var selection = Items.Where(x=>x.IsSelected)<\/em>. Hinzu kommt die oben erw\u00e4hnte Problematik der Virtualisierung \u2013 das Selektions-Property wird entweder \u201eunzuverl\u00e4ssig\u201c, oder die TreeView b\u00fc\u00dft Performance ein.<\/p>\nAuch hier hilf ein Behavior weiter. Es verbindet sich mit dem SelectionChanged-Event der ListBox und synchronisiert so die Liste der selektierten Items der ListBox mit dem ViewModel. Dies sollte nat\u00fcrlich in beide Richtungen geschehen: wenn das ViewModel die Selektion \u00e4ndert, muss sich dies auch in der ListBox widerspiegeln und umgekehrt.<\/p>\n