November 2012 / LINQ to SQL

In meinem letzten Post habe ich LINQ-Abfragen & die Lambda-Ausdrücke beschrieben. Um hier weiterzufahren werde ich nun LINQ to SQL beschreiben, also die Möglichkeit auf einen SQL-Server(in meinem Fall Microsoft SQL Server 2008 R2) zuzugreifen.

Vorbereitung

Um die Funktionen zeigen zu können erstelle ich zunächst eine neue Datenbank namens "TestDB" mithilfe des Management Studios. In dieser Datenbank erstelle ich 2 Tabellen Namens "Projekt" und "Kunde", die eine Beziehung haben. Hier ein ERM davon:

LINQ to SQL-Klasse

Die LINQ to SQL-Klasse arbeitet als OR-Mapper, was bedeutet, dass wir mit ihr komplett objektorientiert auf eine eigentlich Relationale Datenbank zugreifen können.Sie generiert uns Klassen direkt aus unseren Tabellen und stellt eine Datenquelle zur Verfügung. Um nun auf die vorhandene Datenbank zugreifen zu können, verwende ich die vorhandene LINQ to SQL-Klasse. Rechtsklick auf das Projekt, "Hinzufügen", "neues Element", "LINQ to SQL-Klassen" auswählen, sinnvollen Namen geben und hinzufügen:

Nun Befindet sich im Projekt eine neue .dmbl Datei:
Wenn Sie geöffnet wird hat man zuerst diese Ansicht:
Nun müssen Sie die Datenbank auswählen, welche verwendet werde soll. Klicken Sie dazu auf "Server-Explorer" bzw. öffnen Sie diesen und wählen Sie "Mit Datenbank verbinden":
Wählen Sie nun "Microsoft SQL Server" aus, da wir ja auch solch eine Datenbank zugreifen werden:
Geben Sie den SQL-Server Namen an und wählen Sie die gewünschte Datenbank aus:
Wählen Sie im Server-Explorer nun die gewünschten Tabellen, in meinem Fall "Projekt" und "Kunde" auf die linke Seite der weissen fläche, welche angezeigt wird.
Nun ist alles vorbereitet und man kann LINQ benutzen um über die erstellte Verbindung Daten zu holen, zu manipulieren und zu löschen.  Arbeiten mit dem DataContext Die LINQ to SQL-Klasse hat nun eine DataContext-Klasse erstellt mit der wir objektorientiert auf die Datenbank zugreifen können. Der Name der Klasse besteht aus dem Namen der LINQ to SQL-Klasse gefolgt von DataContext. In meinem Fall heisst er DatenbankDataContext und so wird er erstellt: DatenbankDataContext dbContext = new DatenbankDataContext(); Nun können wir mit LINQ oder den Methodenaufrufen, welche ich bevorzuge, auf diesen DataContext zugreifen. Möchte ich z.B. alle Kunden in eine Liste abrufen geht das folgendermassen: dbContext.Kunde.ToList(); Zuerst sollte man jedoch etwas in die Datenbank einfügen. Auch das geht über den DataContext. Möchte ich einen neuen Kunden erstellen gehe ich folgendermassen vor: using(DatenbankDataContext dbContext = new DatenbankDataContext) {     //Wir erstellen einen neuen Kunden     Kunde obj = new Kunde();     //Wir setzen die "Kunde_Name" Eigenschaft     obj.Kunde_Name = "TestKunde";     //Fügt das Kunde-Objekt bei einem Aufruf von SubmitChanges in die DB ein     dbContext.Kunde.InsertOnSubmit(obj);     //Speichert die Änderungen, also den neuen Datensatz     dbContext.SubmitChanges(); } Um einen vorhandenen Datensatz zu editieren muss dieser zuerst ausgelesen werden. Wenn ich nun z.B. die ID des Kunden weiss kann ich das folgendermassen tun: using(DatenbankDataContext dbContext = new DatenbankDataContext) {      //Wir holen den Kunden mit der ID 1      Kunde obj = dbContext.Kunde.Single(k => k.Kunde_ID == 1);      //Wir Ändern die "Kunde_Name" Eigenschaft auf "indico"      obj.Kunde_Name = "indico";      //Speichert die Änderungen      dbContext.SubmitChanges(); } Möchte ich einen vorhandenen Datensatz löschen muss ich auch diesen zuerst auslesen. Wenn ich ebenfalls die ID des Kunden kenne kann ich das folgendermassen tun: using(DatenbankDataContext dbContext = new DatenbankDataContext) {      //Wir holen den Kunden mit der ID 1      Kunde obj = dbContext.Kunde.Single(k => k.Kunde_ID == 1);      //Löscht das Kunde-Objekt bei einem Aufruf von SubmitChanges aus der DB      dbContext.Kunde.DeleteOnSubmit(obj);      //Speichert die Änderungen      dbContext.SubmitChanges(); } Nun kann man eigentlich alles machen was man kann. Auch mit Beziehungen funktioniert das ganze sehr einfach. Erstelle ich ein neues Projekt, welches unbedingt einem Kunden zugewiesen werden muss, bevor es gespeichert werden kann, kann ich der Eigenschaft "Kunde" entweder einen vorhandenen Kunden zuweisen oder sogar einen neuen Erstellen und dann zuweisen. LINQ to SQL erkennt so den neuen Kunden und speichert den bei SubmitChanges() auch gleich in die Datenbank.