Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 6. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Das Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Strukturen und Enumerationen
7 Fehlerbehandlung und Debugging
8 Auflistungsklassen (Collections)
9 Generics – Generische Datentypen
10 Weitere C#-Sprachfeatures
11 LINQ
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 XML
15 Multithreading und die Task Parallel Library (TPL)
16 Einige wichtige .NET-Klassen
17 Projektmanagement und Visual Studio 2012
18 Einführung in die WPF und XAML
19 WPF-Layout-Container
20 Fenster in der WPF
21 WPF-Steuerelemente
22 Elementbindungen
23 Konzepte von WPF
24 Datenbindung
25 Weitere Möglichkeiten der Datenbindung
26 Dependency Properties
27 Ereignisse in der WPF
28 WPF-Commands
29 Benutzerdefinierte Controls
30 2D-Grafik
31 ADO.NET – Verbindungsorientierte Objekte
32 ADO.NET – Das Command-Objekt
33 ADO.NET – Der SqlDataAdapter
34 ADO.NET – Daten im lokalen Speicher
35 ADO.NET – Aktualisieren der Datenbank
36 Stark typisierte DataSets
37 Einführung in das ADO.NET Entity Framework
38 Datenabfragen des Entity Data Models (EDM)
39 Entitätsaktualisierung und Zustandsverwaltung
40 Konflikte behandeln
41 Plain Old CLR Objects (POCOs)
Stichwort

Download:
- Beispiele, ca. 62,4 MB

Buch bestellen
Ihre Meinung?

Spacer
Visual C# 2012 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2012

Visual C# 2012
Rheinwerk Computing
1402 S., 6., aktualisierte und erweiterte Auflage 2013, geb., mit DVD
49,90 Euro, ISBN 978-3-8362-1997-6
Pfeil 28 WPF-Commands
Pfeil 28.1 Allgemeine Beschreibung
Pfeil 28.1.1 Ein einführendes Beispiel
Pfeil 28.2 Vordefinierte WPF-Commands
Pfeil 28.3 Commands verwenden
Pfeil 28.3.1 Command-Bindungen einrichten
Pfeil 28.3.2 Lokalität der Befehlsbindung
Pfeil 28.3.3 Befehlsbindung mit Programmcode
Pfeil 28.3.4 Das Befehlsziel mit »CommandTarget« angeben
Pfeil 28.3.5 Zusätzliche Daten bereitstellen
Pfeil 28.3.6 Befehle mit Maus oder Tastatur aufrufen
Pfeil 28.4 Die Anatomie eines »Command«-Objekts
Pfeil 28.4.1 Das Interface »ICommand«
Pfeil 28.4.2 Die Klassen »RoutedCommand« und »RoutedUICommand«
Pfeil 28.4.3 Das Interface »ICommandSource«
Pfeil 28.5 Das MVVM-Pattern
Pfeil 28.5.1 Ein simples Beispielprogramm

Galileo Computing - Zum Seitenanfang

28.5 Das MVVM-PatternZur nächsten Überschrift

Die Oberfläche einer WPF-Anwendung wird meistens mit XAML-Code erfolgen. Da XAML reindeklarativ ist, müssen komplexere Operationen mit C# in der Code-Behind-Datei implementiert werden. Das wiederum hat zur Folge, dass zwischen der XAML-Datei und der Code-Behind-Datei eine starke Abhängigkeit herrscht.

In der Praxis wird sehr häufig versucht, Abhängigkeiten zu vermeiden. Das ist auch bei WPF-Anwendungen der Fall. Das Aufbrechen der engen Kopplung zwischen XAML- und C#-Code hat mehrere Vorteile:

  • Arbeiten Grafiker und Entwickler gemeinsam an einer WPF-Anwendung, sind die Aufgabenstellungen klarer verteilt, und jeder kann mit seinem »Teil« arbeiten, ohne damit Vorgaben der anderen Seite zu verletzen.
  • Die grafische Benutzeroberfläche kann ohne Probleme nicht nur geändert, sondern sogar ausgetauscht werden, ohne dass die Programmlogik angepasst werden muss.
  • Andererseits kann auch die Programmlogik geändert werden, ohne dass dies eine Änderung der Oberfläche zur Konsequenz hätte.
  • Ohne die Benutzeroberfläche anzeigen zu müssen, kann die Logik mit Unit-Test kontrolliert werden.

An dieser Stelle betritt das MVVM-Pattern die Bühne. MVVM ist das Kürzel für Mode View ViewModel. Durch das Pattern werden drei Blöcke beschrieben:

  • das »Model«
  • der »View«
  • das »ViewModel«

Wir sollten uns zunächst einmal ansehen, welche Aufgabe diesen drei Teilen zukommt.

  • Das Model: Dieser Block repräsentiert die Daten, mit denen in der Anwendung gearbeitet wird. Üblicherweise ist keine Logik implementiert, die die Daten weiterbehandelt. Damit ist das Model auch beispielsweise nicht dafür verantwortlich, Text so zu formatieren, dass er nett dargestellt wird. Ein Model kann beispielsweise die Daten einer Datenbank repräsentieren oder auch die Daten eines Person-Objekts beschreiben, wobei Person eine Klasse in der Anwendung ist. Es gibt nur eine Ausnahme hinsichtlich der Aussage, dass innerhalb des Models keine Programmlogik enthalten ist. Dabei handelt es sich um die Validierung.
  • Der View: Dieser Block des MVVM-Patterns beschreibt das, was der Anwender sieht, also die Darstellung der Daten. Die Programmlogik ist im View nicht enthalten, dazu dient der Block ViewModel. Dennoch muss der View nicht ganz frei von C#-Code sein. Ereignisse, die im Zusammenhang mit der Darstellung stehen, werden innerhalb des Views verarbeitet. Dabei könnte es sich beispielsweise auch um Mausereignisse handeln. Diese werden in der Regel nicht im ViewModel verarbeitet.
  • Das ViewModel: Zwischen die Daten, repräsentiert durch das Model, und die Darstellung der Daten im View ist das ViewModel geschaltet. Es ist also das Bindeglied zwischen View und Model und bildet somit den Kern des MVVM-Patterns, gewissermaßen den Controller. Das ViewModel kann Eingaben aus dem View entgegennehmen oder mit einem anderen Dienst interagieren, um ein Model zu erhalten, um dessen Daten an den View weiterzuleiten. Zu den Aufgaben gehört ferner, mit Methoden und auch Commands den Status des Views aktuell zu halten oder, falls sich im View Daten ändern, diese an das Model zu leiten.Das MVVM-Pattern ist kein Pattern, das einen einzigen Weg zur Separierung der Daten und der Datenansicht beschreibt. Es ist kein Gesetz, denn es gibt mehrere Wege, die eingeschlagen werden können und am Ende zum Ziel führen.Nichtsdestotrotz nehmen die Commands eine bedeutende Rolle in diesem Pattern ein. Deshalb wird das MVVM-Pattern auch in diesem Kapitel behandelt. Doch nähern wir uns dem Pattern langsam in einer sehr einfachen Anwendung.

Galileo Computing - Zum Seitenanfang

28.5.1 Ein simples BeispielprogrammZur vorigen Überschrift

Zunächst einmal sollten wir uns ein Model besorgen. In den folgenden Beispielen dient dazu wieder eine Klasse Person mit den beiden Eigenschaften Name und Alter.

public class Person
{
public string Name { get; set; }
public int Alter { get; set; }

public static Person CreatePerson() {
return new Person { Name = "Franz", Alter = 45 };
}
}

Listing 28.20 Das Model

In der Klasse ist auch die Methode CreatePerson definiert. Diese Methode dient uns einfach nur dazu, Daten einer Person bereitzustellen. Die Methode hat im Kontext des MVVM-Patterns keine Bedeutung.

Wie würde der View ohne Berücksichtigung des Patterns aussehen? Auch das sehen wir uns im folgenden Listing an.

<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition/>
<RowDefinition/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="80"/><ColumnDefinition/>
</Grid.ColumnDefinitions>
<Label>Name:</Label>
<Label Grid.Row="1">Alter</Label>
<TextBlock Grid.Column="1" Text="{Binding Name}"/>
<TextBlock Grid.Column="1" Grid.Row="1" Text="{Binding Alter}" />
</Grid>

Listing 28.21 Der View

Die Daten des Person-Objekts würden wir, mit dem bisherigen Kenntnisstand, aus einer DataContext-Bindung direkt aus dem Objekt beziehen. Also beispielsweise mit dem folgenden C#-Code in der Code-Behind-Datei unter Einbeziehung der Hilfsmethode CreatePerson:

this.DataContext = Person.CreatePerson();

Listing 28.22 Bindung an den Datenkontext des Fensters

Es ist nicht schwer zu erkennen, dass die Daten direkt an die Benutzeroberfläche gebunden werden. Zudem kränkelt das System auch daran, das eine Datenänderung des Objekts nicht an den View weitergeleitet wird, da das Interface INotifyPropertyChanged nicht implementiert ist.

Das wollen wir nun besser machen, dazu die wohl einfachste Form des MVVM-Patterns benutzen und zwischen das Model (also die Klasse Person) und den View (die Benutzeroberfläche) eine weitere Klasse schalten, die im Grunde genommen bereits als ViewModel agiert.

public class PersonViewModel : INotifyPropertyChanged

{
private Person _Model;

// Konstruktor

public PersonViewModel(Person model) {
_Model = model;
_Name = _Model.Name;
_Alter = _Model.Alter;
}

// Schnittstellen-Ereignis

public event PropertyChangedEventHandler PropertyChanged;

protected internal void OnPropertyChanged(string propertyname)
{
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs(propertyname));
}

// Eigenschaften

private string _Name;
public string Name
{
get { return _Name; }
set
{
if (_Name == value) return;
_Name = value;
OnPropertyChanged("Name");
}
}

private int _Alter;
public int Alter
{
get { return _Alter; }
set
{
if (_Alter == value) return;
_Alter = value;
OnPropertyChanged("Alter");
}
}
}

Listing 28.23 Das ViewModel

Das ViewModel stellt dem View eine Bindungsquelle zur Verfügung. Es kapselt das Model und implementiert die einzelnen Komponenten der Person nochmals. Darüber hinaus stellt das ViewModel auch die Schnittstelle INotifyPropertyChanged zur Verfügung, um Datenänderungen entweder an die GUI oder an die private Person-Variable _Model weiterzuleiten.

Im View wird nun eine kleine, aber entscheidende Änderung durchgeführt. Anstatt an die Daten, also das Model, direkt zu binden, erfolgt die Bindung an eine Instanz der ViewModel-Klasse. Damit das ViewModel auch entsprechende Daten zur Verfügung stellen kann, ist in der Klasse PersonViewModel ein Konstruktor definiert.

Die Anbindung an ein Objekt vom Typ des ViewModels in der Code-Behind-Datei ist sehr einfach, wie das folgende Listing zeigt.

public MainWindow()
{
InitializeComponent();
this.DataContext = new PersonViewModel(Person.CreatePerson());
}

Listing 28.24 Anbindung des Views an das ViewModel

Nun ist der View vollkommen unabhängig von den Daten und nur noch an das ViewModel gebunden. Fügen Sie in den View eine Schaltfläche ein, mit der eine Änderung der Objektdaten angestoßen wird, werden die Anzeigesteuerelemente aktualisiert.

Zugegeben, dieses Beispiel ist ausgesprochen einfach, aber es zeigt das MVVM-Pattern in seinen Grundzügen deutlich.

Sie finden dieses Beispiel auf der Buch-DVD unter ..\Beispiele\Kapitel 28\MVVMPattern\ Sample1.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.

>> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2012

Visual C# 2012
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo





Copyright © Rheinwerk Verlag GmbH 2013
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de