Listing 1: Methode zur Ausgabe aller Anreden der Beispieldatenbank<\/span><\/b><\/p>\n Wir erstellen ein neues Objekt auf Basis dieses Typs und speichern es in der Variablen context:<\/p>\n Dann definieren wir eine Variable des Typs var und nennen diese anreden. Sie soll mit der Liste der Anreden des Objekts context gefüllt werden:<\/p>\n Schließlich durchlaufen wir die Elemente der Auflistung anreden <\/b>in einer foreach<\/b>-Schleife und weisen das jeweils aktuelle Objekt der Variablen anrede <\/b>zu. Innerhalb der Schleife geben wir dann die Werte der Eigenschaften ID <\/b>und Bezeichnung <\/b>aller Elemente aus:<\/p>\n Das Ergebnis sieht etwa so aus:<\/p>\n Praktischerweise blendet Visual Studio beim Eingeben der Eigenschaften für das Objekt anrede<\/b> per IntelliSense die verfügbaren Einträge ein (siehe Bild 1).<\/p>\n Bild 1: IntelliSense für den Datenzugriff<\/span><\/b><\/p>\n Fertig – damit wäre der erste Zugriff auf die Daten der Tabelle Anreden<\/b> unserer Beispieldatenbank schon erledigt! Im Folgenden sehen wir uns nun weitere Möglichkeiten an.<\/p>\n Damit die Verbindung zur Datenbank nach dem Abrufen der Daten wieder geschlossen wird, fassen Sie die für den Datenzugriff verwendeten Methoden in ein using<\/b>-Konstrukt ein. Der Grund, ohne weitere Erläuterungen: Die DbContext<\/b>-Klasse, von der unsere Klasse erbt, implementiert das Interface IDisposable<\/b>. Die Nutzung solcher Objekte sollte man innerhalb der using<\/b>-Direktive realisieren. Auf diese Weise wird beim Verlassen des von der using<\/b>-Direktiven eingefassten Abschnitts auf jeden Fall die Dispose<\/b>-Methode aufgerufen, was zum Beispiel die genutzten Ressourcen wieder freigibt. Die verbesserte Version des vorherigen Beispiels sieht nun wie in Listing 2 aus.<\/p>\n Listing 2: Methode zur Ausgabe aller Anreden der Beispieldatenbank mit using<\/span><\/b><\/p>\n Achtung: Die using<\/b>-Variante funktioniert nicht wie gewünscht, wenn Sie die der using<\/b>-Direktiven übergebene Variable bereits vorher deklarieren, wie es hier der Fall ist. Die Variable existiert dann auch noch nach Verlassen von using<\/b>:<\/p>\n Wenn Sie die Daten einer Tabelle sortiert erhalten möchten, können Sie das durch eine Erweiterung einer Abfrage erreichen. Alle Kunden in unsortierter Reihenfolge würde folgendes Statement liefern:<\/p>\n Wenn Sie eine Sortierung hinzufügen wollen, etwa nach dem Feld Nachname<\/b>, haben Sie zwei Möglichkeiten – eine mit der Methodensyntax und eine mit der Abfragesyntax.<\/p>\n Für beide fügen Sie zunächst eine Referenz auf den Namespace System.Linq <\/b>zur Klassendatei hinzu:<\/p>\n Nun erstellen Sie eine Methode wie in Listing 3. Der Unterschied zur Ermittlung der unsortierten Kunden liegt in der folgenden Zeile:<\/p>\n Listing 3: Methode zur Ausgabe der Kunden, sortiert nach dem Nachnamen (Methodensyntax)<\/span><\/b><\/p>\n Hier haben wir noch die Methode OrderBy <\/b>an die Eigenschaft Kunden <\/b>angehängt und dieser als Parameter die Vorgabe für die Sortierung mitgegeben, nämlich d => d.Nachname<\/b>.<\/p>\n Dabei handelt es sich um einen sogenannten Lambda-Ausdruck. Lambda-Ausdrücke haben wir in diesem Magazin noch nicht besprochen, daher gehen wir hier nur darauf ein, wie diese für den vorliegenden Anwendungszweck formuliert werden.<\/p>\n Der Lambda-Ausdruck, den wir hier als Parameter der OrderBy <\/b>(und später auch der OrderByDescending<\/b>-, der Where<\/b>– und anderer Methoden) nutzen, enthält zwei Teile: Der Teil vor dem Lambda-Zeichen (=><\/b>, nicht zu verwechseln mit =><\/b>) enthält den Namen für das, was wir im Teil hinter dem Lambda-Zeichen untersuchen wollen.<\/p>\n Wir untersuchen immer das Objekt, für das wir die Methode OrderBy <\/b>(OrderByDescending<\/b>, Where<\/b>, …) aufrufen, in diesem Fall also context.Kunde<\/b>, also die Auflistung der Kunden-Entitäten, und geben dieser im vorliegenden Fall den Namen d<\/b> (Sie können auch einen anderen Buchstaben oder Ausdruck statt d <\/b>verwenden).<\/p>\n Dies können wir dann im zweiten Teil des Lambda-Ausdrucks aufgreifen. Im Falle der OrderBy<\/b>-Methode geben wir also beispielsweise an, wonach wir sortieren wollen – hier die Eigenschaft Nachname <\/b>der Kunde<\/b>-Entitäten.<\/p>\n In der Variablen kunden <\/b>landet dann die sortierte Liste der Kunde<\/b>-Entitäten, die wir wieder in einer foreach<\/b>-Schleife durchlaufen. Diesmal geben wir den Primärschlüsselwert sowie den Nachnamen der Kunden aus:<\/p>\n Die zweite Methode zum Abfragen von Daten unter LINQ to Entities verwendet die sogenannte Abfragesyntax. Hier stellen Sie einen Abfrageausdruck zusammen, der eher wie ein SQL-Ausdruck aussieht. Um das gleiche Ergebnis wie im obigen Beispiel mit der Methodensyntax zu erzielen, ersetzen Sie die Zeile mit der OrderBy<\/b>-Methode und dem Lambda-Ausdruck durch die folgende Zeile:<\/p>\n Dies sieht für erfahrene SQL-Nutzer etwas intuitiver aus, da hier einige Elemente wie from<\/b>, orderby <\/b>und select <\/b>auftauchen. Die Reihenfolge ist hier etwas anders als beim Lambda-Ausdruck. Die Zuweisung des Ergebnisses erfolgt wieder an die Variable kunden<\/b>. Danach geben wir an, woher die Daten kommen und welchen Alias-Namen wir nachfolgend dafür verwenden wollen (from d in context.Kunden<\/b>).<\/p>\n Dann legen wir die Operation fest, in diesem Fall wieder die Sortierung (orderby d.Nachname<\/b>). Schließlich gibt select d <\/b>an, was zurückgegeben werden soll. Beim vollständigen Beispiel ändert sich also nur die Zeile mit der Definition der Abfrage (siehe Listing 4).<\/p>\n Listing 4: Methode zur Ausgabe der Kunden, sortiert nach dem Nachnamen (Abfragesyntax)<\/span><\/b><\/p>\n Sowohl bei der Methodensyntax als auch bei der Abfragensyntax unterstützt Visual Studio Sie mit IntelliSense.<\/p>\n Unter SQL haben Sie für eine absteigende Sortierung das Schlüsselwort DESC <\/b>hinten angefügt (ORDER BY Nachname DESC<\/b>). Unter LINQ to Entities verwenden Sie bei der Methodensyntax einfach eine andere Methode (OrderByDescending<\/b>):<\/p>\n Bei der Abfragensyntax fügen Sie ähnlich wie bei SQL ein Schlüsselwort hinzu, hier descending<\/b>:<\/p>\n Nun steigern wir den Schwierigkeitsgrad und wollen nur bestimmten Datensätze der Tabelle Kunden <\/b>als Objekt ermitteln und durchlaufen. Unter Access\/VBA brauchen wir dazu nur die SELECT<\/b>-Anweisung in der OpenRecordset<\/b>-Methode zu ändern. Unter C#\/LINQ to Entities ist es auch nicht viel komplizierter – genau genommen haben Sie die Grundlagen dazu schon oben mit der Sortierung kennen gelernt.<\/p>\n Wenn Sie beispielsweise den Kunden ermitteln wollen, dessen Eigenschaft Nachname <\/b>den Wert Minhorst <\/b>enthält, formulieren Sie die Abfrage in der Methodensyntax wie folgt (siehe Methode KundeMitNachname_Methodensyntax<\/b>).<\/p>\n Sie verwenden also die Where<\/b>-Methode statt der OrderBy<\/b>-Methode:<\/p>\n In der Abfragensyntax erledigen Sie die Aufgabe mit dieser Zeile (siehe Methode KundeMitNachname_Abfragesyntax<\/b>). Hier kommt also das where<\/b>-Schlüsselwort mit dem Vergleichskriterium hinzu:<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>BestellverwaltungEntities context = \r\n new BestellverwaltungEntities();<\/pre>\n
var anreden = context.Anreden;<\/pre>\n
foreach (var anrede in anreden) {\r\n Console.WriteLine(\"{0} {1}\", \r\n anrede.ID, anrede.Bezeichnung);\r\n}<\/pre>\n1 Herr\r\n2 Frau<\/pre>\n
![\"IntelliSense](\"..\/fileadmin\/_temp_\/2016_04\/pic_48_001.png\")
<\/p>\nVerbesserung: using verwenden<\/h2>\n
public static void AlleAnredenAusgeben_ForEach_Besser() {\r\n using (BestellverwaltungEntities context = new BestellverwaltungEntities()) {\r\n var anreden = context.Anreden;\r\n foreach (var anrede in anreden) {\r\n Console.WriteLine(\"{0} {1}\", anrede.ID, anrede.Bezeichnung);\r\n }\r\n }\r\n Console.ReadLine();\r\n}<\/pre>\nBestellverwaltungEntities context = \r\n new BestellverwaltungEntities()\r\nusing (context) {\r\n ... }<\/pre>\nKunden sortiert ausgeben<\/h2>\n
var kunden = context.Kunden;<\/pre>\n
Abfragen mit der Methodensyntax<\/h2>\n
using System.Linq;<\/pre>\n
public static void KundenNachNachname_MethodenSyntax() {\r\n using (BestellverwaltungEntities context = new BestellverwaltungEntities()) {\r\n var kunden = context.Kunden.OrderBy(d => d.Nachname);\r\n foreach (var kunde in kunden) {\r\n Console.WriteLine(\"{0} {1}\", kunde.ID, kunde.Nachname);\r\n }\r\n }\r\n Console.ReadLine();\r\n}<\/pre>\nvar kunden = context.Kunden.OrderBy(d => d.Nachname);<\/pre>\n
8 Ackermann\r\n9 Alberts\r\n10 Becker\r\n11 Fröhlich\r\n4 Meier\r\n1 Minhorst\r\n2 Müller\r\n7 Schmidt<\/pre>\n
Abfragen mit der Abfragesyntax<\/h2>\n
var kunden = \r\nfrom d in context.Kunden \r\norderby d.Nachname \r\nselect d;<\/pre>\n
public static void KundenNachNachname_Abfragesyntax() {\r\n using (BestellverwaltungEntities context = new BestellverwaltungEntities()) {\r\n var kunden = from d in context.Kunden orderby d.Nachname select d;\r\n foreach (var kunde in kunden) {\r\n Console.WriteLine(\"{0} {1}\", kunde.ID, kunde.Nachname);\r\n }\r\n }\r\n Console.ReadLine();\r\n}<\/pre>\nAbsteigende Sortierung<\/h2>\n
var kunden = \r\ncontext.Kunden.OrderByDescending(d => d.Nachname);<\/pre>\n
var kunden = \r\nfrom d in context.Kunden \r\norderby d.Nachname descending \r\nselect d;<\/pre>\n
Kunden nach bestimmten Kriterien ausgeben<\/h2>\n
var kunden = \r\ncontext.Kunden.Where(d => d.Nachname == \"Minhorst\");<\/pre>\n
var kunden = \r\nfrom d in context.Kunden \r\nwhere d.Nachname == \"Minhorst\" \r\nselect d;<\/pre>\n
Platzhalter<\/h2>\n
\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