- Model (zB. Database-Objects)
- ViewModel
- View
Jedoch erschwert die Implementierung oft die Arbeit und können auch den Code unleserlich machen. Das kann dann soweit führen, dass man für jedes Model eine Wrapper-Klasse erstellt.
Eine Ausführliche Erklärung des MVVM Patterns ist in diesem sehr zu empfehlenden Artikel zu finden:
Aber das .Net 4.0-Framework schafft Abhilfe. Es ermöglicht nämlich eine dynamische Programmierung. Mit diesem Feature ist es nun möglich diese Mechanismen für die entsprechenden ViewModels automatisch zu erzeugen. Dies ist übrigens auch WPF Version 4 zu verdanken:
WPF supports data binding to objects that implement IDynamicMetaObjectProvider. For example, if you create a dynamic object that inherits from DynamicObject in code, you can use markup extension to bind to the object in XAML. For more information, see the Binding Sources Overview.(Quelle: http://msdn.microsoft.com/en-us/library/bb613588(VS.100).aspx#binding)
Damit der nachfolgende Artikel nachvollziehbar ist, solltet ihr euch auch einen Artikel über die DLR ansehen:
Wie in den Artikeln zu lesen, können Klassen geschaffen werden, deren Properties (sogar Methoden) dynamisch erstellt werden. Das machen wir uns zu nutze um das INotifyPropertyChange-Interface dynamisch zu wrappen. Außerdem wäre es nicht schlecht, wenn man im ViewModel die Commands bequem über Attributes definieren könnte und sich somit die Initialisierung der ICommand-Properties spart. Ich habe mir das ungefähr so vorgestellt:
public class MainViewModel
{
public MainViewModel() { }
public IList<User> UserCollection { get; set; }
public IList<Article> ArticleCollection { get; set; }
public string Title { get; set; }
[Command("AddArticleCommand", "CanAddArticle",
typeof(MainViewModel), new String[] {"Title"})]
public void AddArticleCommandExecute(object objArticle)
{
Article article = objArticle as Article;
Console.WriteLine("Add article " + article.Name);
Title = article.Name;
}
public bool CanAddArticle(object objArticle)
{
return objArticle != null;
}
[Command]
public void HelpCommandExecute(object obj)
{
Console.WriteLine("Here you get some help.");
}
}
Zu sehen ist die Klasse MainViewModel mit 3 Properties und 3 Methoden. Der Wrapper soll nun dafür sorgen, dass beim setzen eines Properties das PropertyChangedEvent ausgelöst wird. Außerdem sollen ICommand-Properties für jede Methode, die mit einem Command-Attribut versehen ist dynamisch erzeugt werden.Schritt 1: INotifyPropertyChanged
Beginnen wir also mit der Implementierung der Wrapper-Klasse. Ich habe hier eine generische Klasse genommen. Das hat den Vorteil, dass man aufwendigen Reflection-Operationen für einen Typen nur einmal aufwenden muss. Diesen Teil der Arbeit habe ich nämlich in einen Static-Konstruktor gepackt:public sealed class DynamicViewModel<T> : DynamicObject, INotifyPropertyChanged
{
private static readonly SortedDictionary<string, PropertyInfo> properties = new ...;
static DynamicViewModel()
{
// init all properties
var props = typeof(T)
.GetProperties()
.Where(p => p.CanRead);
foreach (var p in props)
properties.Add(p.Name, p);
}
...
}
Wie im Code zu sehen, werden alle Readable Properties des Types T abgefragt und in eine Map gespeichert. Diese Map benöigen wir jetzt für das Setzen und Zurückgeben der veimeindlichen Properties. Hierfür überschreiben wir die zwei Methoden der Klasse DynamicObject: TryGetMember, TrySetMember:
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
PropertyInfo propInf = null;
if (properties.TryGetValue(binder.Name, out propInf))
{
result = propInf.GetValue(instance, null);
}
else
{
// if debug mode do some extra stuff.
result = null;
return false;
}
return true;
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
PropertyInfo propInf = null;
if (properties.TryGetValue(binder.Name, out propInf) && propInf.CanWrite)
{
propInf.SetValue(instance, value, null);
OnPropertyChanged(propInf.Name); /* Hier wird das PropertyChangedEvent ausgelöst */
return true;
}
else
{
// if debug mode do some extra stuff.
return false;
}
}
Und siehe da, jetzt wird beim setzen der Properties automatisch das PropertyChangedEvent ausgelöst (Zeile 26):
dynamic viewModel = new DynamicViewModel<MainViewModel>(new MainViewModel(), true);
PropertyChangedEventHandler handler = (s, e) =>
Console.WriteLine("Property Changed: " + e.PropertyName);
viewModel.PropertyChanged += handler;
viewModel.Title = "Neuer Titel!";
// Ausgabe: Property Changed: Title
Das ist schonmal nicht schlecht. Aber jetzt kommen wir zum etwas komplizierteren Teil: Die dynamische Erstellung der Commands.
