Ok, jetzt wird's schwer für mich, da ich keine Ahnung von MVVM habe und Dein Beispiel sieht gut aus, aber lässt viele Fragen bei mir entstehen. Könntest Du mich da vielleicht erleuchten?
public class MyItem : INotifyPropertyChanged
{
#region INotifyPropertyChanged Members
protected void OnPropertyChanged(string propertyName)
{
var evt = this.PropertyChanged;
if (evt != null)
evt(this, new PropertyChangedEventArgs(propertyName));
}
public event PropertyChangedEventHandler PropertyChanged;
#endregion
Also, eine neue Klasse deklarieren und diese von INotifyPropertyChanged ableiten. Das macht dann PropertyChanged Events erst möglich und benachrichtigt den Client über Werteänderungen, ok.
Wobei mir hier die Zeile mit dem evt() Kopfzerbrechen bereitet. Erst wird evt als Variable deklariert und mit dem Wert von PropertyChanged belegt und danach wird sie als Methode aufgerufen und man übergibt "this" and diese "Methode" und
erstellt einen neuen PropertyChangedEventArgs und übergibt daran etwas was vorher nirgends deklariert wurde (propertyName)?
Danach kommt folgendes:
private string _Header = "Item";
public string Header
{
get
{
return this._Header;
}
set
{
if (this._Header != value)
{
this._Header = value;
this.OnPropertyChanged("Header");
}
}
}
Hier wird, wenn sich der Header ändert in der Klasse das Item geändert im TreeView, korrekt?
private ObservableCollection<MyItem> _SubItems = new ObservableCollection<MyItem>();
public ObservableCollection<MyItem> SubItems
{
get
{
return this._SubItems;
}
set
{
if (this._SubItems != value)
{
this._SubItems = value;
this.OnPropertyChanged("SubItems");
}
}
}
}
Das ist jetzt etwas mit dem ich nicht viel anfangen kann. Eine Observable Collection die in der Klasse deklariert ist, welche von sich selbst abgeleitet ist? Ich gehe mal davon aus, dass eine ObservableCollection so in etwa das gleiche wie eine List<>
ist, nur für andere Objekte geeignet und mit Methoden für die Überwachung. Aber wie kann ich denn <MyItem>
innerhalb der Klasse "MyItem" verwenden? Und kann dieses SubItems dann auch noch verschachtelt werden? Ich brauche 6 Ebenen, eine Hauptebene und 5 Unterebenen.
Im Codebehind des Fensters deklaarierst du nun eine Liste mit den Items
Wie? Ich muss diese ja irgendwie als Items, SubItems, SubSubItems, SubSubSubItems, etc. definieren und dann auch irgendwie diesen Klassen hinzufügen. Wo und wie füge ich das ein? Irgendwo sehe ich noch nicht ganz die Zusammenhänge.
---
und weißt den DataContext im Konstruktor zu:
public partial class MainWindow : Window
{
public MainWindow()
{
this.DataContext = this;
InitializeComponent();
}
public ObservableCollection<MyItem> Items { get; set; }
Ich weise auf den DataContext von this, this zu? Die Logik dahinter erschließt sich mir irgendwie nicht. Würde das nicht zu einer endlosen Schleife führen beim Zugriff auf den DataContext, weil dieser ja this ist und der DataContext von this ist this.DataContext,
oder was verstehe ich da falsch?
<TreeView ItemsSource="{Binding Items}">
<TreeView.ItemTemplate>
<HierarchicalDataTemplate ItemsSource="{Binding SubItems}">
<TextBlock Text="{Binding Header}"/>
</HierarchicalDataTemplate>
</TreeView.ItemTemplate>
</TreeView>
Ok, also der TreeView wird erzeugt und bekommt als DatenSource "Items" angebunden, was ja aus der Klasse MyItem stammt, müsste dann aber nicht die Deklaration MyItem.Items sein?
Dann wird ein ItemTemplate erstellt in dem ein hierarchisches DatenTemplate definiert wird, welches als Source für seine Items "SubItems" angebunden bekommt, was ja auch wieder aus MyItem stammt.
Und darin wird zum Schluß ein Textblock mit dem Header als Text eingebunden.
Ich könnte also mit meiner Logik die Listen erstellen und anbinden, aber muss ich dann für jedes SubItem eine neue Liste anlegen? Das würden dann 5953 Listen (so viele unterschiedliche Gruppen und Untergruppen existieren in bis zu 6 Ebenen) werden. Das muss
ich irgendwie autoamtisieren.
