{"id":55000077,"date":"2017-02-01T00:00:00","date_gmt":"2020-03-27T19:25:10","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=77"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"EDM_1nBeziehungen_mit_DataGrid","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/EDM_1nBeziehungen_mit_DataGrid\/","title":{"rendered":"EDM: 1:n-Beziehungen mit DataGrid"},"content":{"rendered":"

Unter Access haben wir 1:n-Beziehungen einfach in einem Haupt- und einem Unterformular abgebildet, wobei wir beiden einfach die Datenquellen und gebundenen Steuerelemente zugewiesen haben – den Rest hat Access automatisch erledigt. Unter C# und WPF ist das ein wenig mehr Arbeit, aber nach der Lektüre dieses Artikels haben Sie das Wissen, das für die Anzeige zweier per 1:n-Beziehung verknüpfter Tabellen in einem Fenster beziehungsweise einer Seite und einem DataGrid als Unterformular-Ersatz nötig ist.<\/b><\/p>\n

Beispieldaten<\/h2>\n

Als Beispiel wollen wir uns die Kategorien und die damit verknüpften Produkte ansehen. Dabei sollen die beiden Felder einer Kategorie im Fenster\/in der Seite selbst angezeigt werden, die dazugehörigen Produkte in einem DataGrid unter den Kategoriedaten. Wir verwenden die SQLite-Datenbank Bestellverwaltung.db <\/b>und ein daraus abgeleitetes Entity Data Model namens BestellverwaltungEntities.edmx <\/b>als Datenquelle. Die verwendeten Auflistungen beziehungsweise Entitäten heißen Kategorien<\/b>, Kategorie<\/b>, Produkte <\/b>und Produkt<\/b>.<\/p>\n

Einbau in die Bestellverwaltung<\/h2>\n

In einigen weiteren Beiträgen verwenden wir die Bestellverwaltung als Beispielanwendung. Diese verwendet im Office-Stil ein Ribbon zur Auswahl der verschiedenen Bereiche und Funktionen. Die einzelnen Bereiche etwa zur Anzeige einer Kundenliste oder einer Kundendetailansicht werden auf Seiten (Page<\/b>) statt auf eigenen Fenstern (Window<\/b>) erstellt und je nach angeklickter Ribbon-Schaltfläche in einem Frame-Element eingeblendet – also etwa wie die Unterformulare in einem Unterformular-Steuerelement in Access. Wir fügen also in diesem Artikel weitere Page<\/b>-Elemente hinzu, die dann nach dem Anklicken der ebenfalls noch anzulegenden Ribbon-Schaltflächen angezeigt werden sollen.<\/p>\n

Ribbon-Einträge<\/h2>\n

Als Erstes legen wir die drei Ribbon-Einträge an, die Sie in Bild 1 sehen. Die Elemente für diese Ribbon-Gruppe sehen wie folgt aus:<\/p>\n

\"Übersicht<\/p>\n

Bild 1: Übersicht der Kategorien<\/span><\/b><\/p>\n

<RibbonGroup Header=\"Kategorien\">    \/\/MainWindow.xaml\r\n     <RibbonButton Name=\"btnKategorieuebersicht\" Label=\"Übersicht\" Click=\"btnKategorieuebersicht_Click\"\r\n         LargeImageSource=\"images\/elements4.png\"><\/RibbonButton>\r\n     <RibbonButton Name=\"btnNeueKategorie\" Label=\"Neue Kategorie\" Click=\"btnNeueKategorie_Click\" \r\n         LargeImageSource=\"images\/elements4_new.png\"><\/RibbonButton>\r\n     <RibbonButton Name=\"btnKategorieLoeschen\" Label=\"Kategorie löschen\" Click=\"btnKategorieLoeschen_Click\" \r\n         LargeImageSource=\"images\/elements4_delete.png\"><\/RibbonButton>\r\n<\/RibbonGroup><\/pre>\n
Wir haben für jedes Element ein Bild hinterlegt, das wir gleichzeitig zum Ordner images <\/b>des Projekts hinzugefügt haben.<\/p>\n
Übersichtsseite für die Kategorien<\/h2>\n
Die Kategorien werden in der Übersichtsseite KategorieUebersicht.xaml <\/b>in einem DataGrid<\/b>-Element aufgelistet. Das Füllen dieses DataGrid<\/b>-Elements erfolgt genauso, wie wir es bereits im Artikel EDM: Kunden verwalten mit Ribbon <\/b>für die Anzeige der Kunden realisiert und im Artikel Bestellveraltung planen <\/b>angepasst haben – nur, dass wir diesmal auf die Entitätsliste der Kategorien statt der Kunden zugreifen und nur die Felder ID <\/b>und Bezeichnung <\/b>anzeigen.<\/p>\n
Detailseite für die Kategorien<\/h2>\n
Der interessante Teil folgt nun, nämlich die Detailseite für eine Kategorie. Eine Kategorie enthält zwar nur die beiden Felder ID <\/b>und Bezeichnung<\/b>, was sich genau so leicht abbilden lässt wie in der Detailansicht für Kunden (Kundendetails.xaml<\/b>) – nur mit weniger Feldern. Allerdings wollen wir ja zu jeder Kategorie auch noch die Liste der Produkte anzeigen, die der jeweiligen Kategorie zugeordnet sind! Und das wollen wir wiederum mit einem DataGrid<\/b>-Element erledigen.<\/p>\n
Im Grunde brauchen wir also eine Kombination der bereits einmal gezeigten Detailansicht für die Kunden (diesmal für die Kategorien) und einer Übersicht für die Produkte. Der Unterschied bei der Übersichtsseite diesmal ist, dass wir nicht mehr einfach alle Elemente der Produkte-Liste anzeigen können, sondern nur noch diejenigen Elemente, die der aktuellen Kategorie zugeordnet sind. Die Definition der Seite mit den Kategoriedetails und der Produktliste startet mit ein paar Page.Resources<\/b>-Elementen, welche globale Attribute der verschiedenen Steuerelemente festlegen und die wir hier ebenso gekürzt haben wie die Definition des Grids:<\/p>\n
<Page x:Class=\"Bestellverwaltung.Kategoriedetails\" ...Title=\"Kategoriedetails\">    \/\/Kategoriedetails.xaml\r\n     <Page.Resources>...<\/Page.Resources>\r\n     <Grid>\r\n         <Grid.ColumnDefinitions>...<\/Grid.ColumnDefinitions>\r\n         <Grid.RowDefinitions>...<\/Grid.RowDefinitions><\/pre>\n
Danach folgt das Label für die ID <\/b>der Kategorie und die TextBox<\/b>, die wir an das Feld kategorie.ID <\/b>binden:<\/p>\n
         <Label Content=\"ID:\" Grid.Column=\"0\" \/>\r\n         <TextBox x:Name=\"txtID\" Grid.Column=\"1\" HorizontalAlignment=\"Left\" Text=\"{Binding kategorie.ID, Mode=TwoWay,             ValidatesOnExceptions=true}\" Width=\"50\" IsEnabled=\"False\" BorderBrush=\"Transparent\" \/><\/pre>\n
Die Bezeichnung erhält ebenfalls ein Label und eine Bindung an das Feld kategorie.Bezeichnung<\/b> – beide landen in jeweils einer Spalte, genau wie die Steuerelemente für die ID:<\/p>\n
         <Label Content=\"Bezeichnung:\" Grid.Column=\"0\" Grid.Row=\"1\" \/>\r\n         <TextBox x:Name=\"txtBezeichnung\" Grid.Column=\"1\" HorizontalAlignment=\"Stretch\" Grid.Row=\"1\"             Text=\"{Binding kategorie.Bezeichnung, Mode=TwoWay, ValidatesOnDataErrors=true}\" \/><\/pre>\n
Schließlich folgt das DataGrid<\/b>-Element namens dgProdukte<\/b>, das in der folgenden Zeile landet und sich über zwei Spalten erstrecken soll (Grid.ColumnSpan=”2″<\/b>). Als ItemsSource <\/b>für das DataGrid <\/b>legen wir das Element Produkte <\/b>fest. Das automatische Generieren der Spalten sowie das Anzeigen einer leeren Spalte zum Hinzufügen von Elementen deaktivieren wir:<\/p>\n
         <DataGrid x:Name=\"dgProdukte\" Grid.Column=\"0\" Grid.Row=\"2\" Grid.ColumnSpan=\"2\" ItemsSource=\"{Binding Produkte}\"                 AutoGenerateColumns=\"false\" CanUserAddRows=\"False\"><\/pre>\n
Die beiden Spalten des DataGrid<\/b>-Elements binden wir an die Felder ID <\/b>und Bezeichnung<\/b>:<\/p>\n
             <DataGrid.Columns>\r\n                 <DataGridTextColumn Binding=\"{Binding Path=ID}\" Header=\"ID\"  \/>\r\n                 <DataGridTextColumn Binding=\"{Binding Path=Bezeichnung}\" Header=\"Produkt\" \/>\r\n             <\/DataGrid.Columns><\/pre>\n
Außerdem wollen wir, wie schon bei den übrigen Übersichten, ein Öffnen der Produktdetails per Doppelklick erlauben und fügen dazu einen EventSetter <\/b>hinzu:<\/p>\n
             <DataGrid.Resources>\r\n                 <Style TargetType=\"DataGridRow\">\r\n                     <EventSetter Event=\"MouseDoubleClick\" Handler=\"Row_DoubleClick\"\/>\r\n                 <\/Style>\r\n             <\/DataGrid.Resources>\r\n         <\/DataGrid><\/pre>\n
Schließlich folgen noch die beiden Schaltflächen zum Speichern und Verwerfen der aktuellen Änderungen:<\/p>\n
         <StackPanel Orientation=\"Horizontal\" Grid.Row=\"6\" Grid.ColumnSpan=\"4\" >\r\n             <Button x:Name=\"btnSpeichern\" Margin=\"3\" Padding=\"3\" Click=\"btnSpeichern_Click\" Height=\"23\"                 Content=\"Speichern\"><\/Button>\r\n             <Button x:Name=\"btnVerwerfen\" Margin=\"3\" Padding=\"3\" Click=\"btnVerwerfen_Click\" Height=\"23\"                 Content=\"Verwerfen\"><\/Button>\r\n         <\/StackPanel>\r\n     <\/Grid>\r\n<\/Page><\/pre>\n
Der Entwurf sieht in der XAML-Ansicht nun wie in Bild 2 aus. Im Entwurf haben wir nun schon einige Bindungen gesehen, die wir nun in der Code behind-Klasse bereitstellen wollen. Diese Klasse enthält zunächst eine Variable für das DBContext<\/b>-Element, über das wir auf das Entity Data Model zugreifen (dbContext<\/b>). Außerden finden wir hier die Definition für die Objekte, an die wir die Elemente der XAML-Seite binden wollen. Die erste ist das Kategorie<\/b>-Objekt, das wir in der öffentlichen Variablen kategorie <\/b>speichern.<\/p>\n
\"Entwurf<\/p>\n
Bild 2: Entwurf der Kategoriedetail-Seite<\/span><\/b><\/p>\n
Die zweite ist das ObservableCollection<\/b>-Objekt Produkte<\/b>, dessen Inhalt wir in der als privat deklarierten Variablen produkte <\/b>speichern und über entsprechende Eigenschaften für den Zugriff von außen bereitstellen:<\/p>\n
public partial class Kategoriedetails : Page {    \/\/Kategoriedetails.xaml.cs\r\n     private BestellverwaltungEntities dbContext;\r\n     public Kategorie kategorie { get; set; }\r\n     private ObservableCollection<Produkt> produkte;\r\n     public ObservableCollection<Produkt> Produkte {\r\n         get {\r\n             return produkte;\r\n         }\r\n         set {\r\n             produkte = value;\r\n         }\r\n     }\r\n     ...\r\n}<\/pre>\n
Die Konstruktor-Methode Kategoriedetails<\/b>, die beim Erstellen eines Objekts auf Basis unserer Klasse aufgerufen wird, erwartet als Parameter den Primärschlüsselwert der ID einer Kategorie. Wird dieser nicht übergeben, setzt die Methode ihn auf 0 <\/b>fest – dies bedeutet, dass ein neues, leeres Kategorie<\/b>-Element angezeigt werden soll.<\/p>\n
Die Methode erstellt ein neues Objekt auf Basis der Klasse BestellverwaltungEntities <\/b>und stellt den DataContext <\/b>auf die Code behind-Klasse (this<\/b>) ein, damit die XAML-Elemente auf die per Eigenschaft zugängig gemachten Elemente der Code behind-Klasse zugreifen können. Ist die mit dem Parameter kategorieID <\/b>übergebene ID <\/b>der Kategorie nicht gleich 0<\/b>, sucht die Find<\/b>-Methode in der Kategorien<\/b>-Auflistung nach dem entsprechenden Element. Anderenfalls wird ein neues Kategorie-Element angelegt.<\/p>\n
public Kategoriedetails(long kategorieID = 0) {    \/\/Kategoriedetails.xaml.cs\r\n     InitializeComponent();\r\n     dbContext = new BestellverwaltungEntities();\r\n     DataContext = this;\r\n     if (kategorieID != 0) {\r\n         kategorie = dbContext.Kategorien.Find(kategorieID);\r\n     }\r\n     else {\r\n         kategorie = new Kategorie();\r\n         dbContext.Kategorien.Add(kategorie);\r\n     }\r\n     produkte = new ObservableCollection<Produkt>(dbContext.Produkte.Where(d => d.KategorieID == kategorie.ID));\r\n}<\/pre>\n
Danach folgt der interessante Schritt: Wir füllen das DataGrid, und zwar nur mit den Entitäten, die einem bestimmten Suchkriterium entsprechen.<\/p>\n
Dieses soll nur die Entitäten liefern, deren Feld KategorieID <\/b>dem Wert des Feldes ID <\/b>der angezeigten Kategorie<\/b>-Entität entspricht. Dazu verwenden wir einen entsprechenden Linq-Ausdruck (siehe auch Artikel LINQ to Entities: Daten abfragen<\/b>):<\/p>\n
produkte = new ObservableCollection<Produkt>(dbContext.Produkte.Where(d=>d.KategorieID==kategorie.ID));<\/pre>\n
Das Ergebnis sieht dann wie in Bild 3 aus.<\/p>\n
\"Anzeige<\/p>\n
Bild 3: Anzeige von Kategorien und Produkten<\/span><\/b><\/p>\n
Fokus auf Bezeichnung<\/h2>\n
Damit gleich beim Öffnen der Seite der Fokus auf das Textfeld zur Eingabe der Bezeichnung gelegt wird, geben Sie für das Page<\/b>-Objekt den Wert Page_Loaded <\/b>für das Attribut Loaded <\/b>an:<\/p>\n
<Page x:Class=\"Bestellverwaltung.Kategoriedetails\" ... Loaded=\"Page_Loaded\">    \/\/Kategoriedetails.xaml<\/pre>\n
Dies soll die folgende Ereignismethode auslösen, die lediglich den Fokus auf das Feld txtBezeichnung <\/b>legt:<\/p>\n
private void Page_Loaded(object sender, RoutedEventArgs e) {    \/\/Kategoriedetails.xaml.cs\r\n     txtBezeichnung.Focus();\r\n}<\/pre>\n
Speichern der Kategorie<\/h2>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t