Exemplarische Vorgehensweise: Erstellen von LINQ to SQL-Klassen (O/R-Designer)

Aktualisiert: November 2007

Der Object Relational Designer (O/R-Designer) stellt eine visuelle Entwurfsoberfläche zum Erstellen und Bearbeiten von LINQ to SQL-Klassen (Entitätsklassen) bereit, die auf Objekten in einer Datenbank basieren. Mithilfe von LINQ to SQL können Sie LINQ-Technologie verwenden, um auf SQL-Datenbanken zuzugreifen. Weitere Informationen finden Sie unter Sprachintegrierte Abfrage (Language-Integrated Query, LINQ).

Diese exemplarische Vorgehensweise enthält Schritte zum Erstellen von LINQ to SQL-Entitätsklassen, die den Tabellen Customers und Orders in der Datenbank Northwind zugeordnet sind, und zum Anzeigen der Daten in einem Windows Form. Zusätzlich zu den Schritten zum Anzeigen der Daten aus der Tabelle werden Schritte zum Binden von Daten an eine LINQ-Abfrage bereitgestellt. Schließlich werden die Schritte zum Verwenden von gespeicherten Prozeduren beschrieben, um die standardmäßige LINQ to SQL-Logik zum Senden von Aktualisierungen von den Entitätsklassen zur Datenbank zu ersetzen.

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie die folgenden Aufgaben ausführen:

• Hinzufügen einer LINQ to SQL-Datei zum Projekt.

• Erstellen von neuen Entitätsklassen, die den verknüpften Tabellen in der Datenbank zugeordnet sind.

• Erstellen einer Objektdatenquelle, die auf die Entitätsklassen verweist.

• Erstellen eines Windows Form, das an Entitätsklassen gebundene Steuerelemente enthält.

• Hinzufügen von Code, um die Daten zwischen den Entitätsklassen und der Datenbank zu laden und zu speichern.

• Erstellen einer einfachen LINQ-Abfrage und Anzeigen der Ergebnisse im Formular.

• Hinzufügen von gespeicherten Prozeduren zum O/R-Designer.

• Konfigurieren einer Entitätsklasse, um gespeicherte Prozeduren zum Einfügen, Aktualisieren und Löschen zu verwenden.

Vorbereitungsmaßnahmen

Zum Durchführen dieser exemplarischen Vorgehensweise benötigen Sie Folgendes:

• Zugriff auf die SQL Server-Version der Beispieldatenbank Northwind. Weitere Informationen finden Sie unter Gewusst wie: Installieren von Beispieldatenbanken.

• Die gespeicherte Prozedur UpdateCustomer für die Datenbank Northwind. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Erstellen von gespeicherten Prozeduren zum Aktualisieren der Northwind-Kundentabelle.

Erstellen der Windows-Anwendung

Da Sie mit LINQ to SQL-Klassen arbeiten und die Daten in einem Windows Form angezeigt werden, besteht der erste Schritt in dieser exemplarischen Vorgehensweise in der Erstellung einer neuen Windows Forms-Anwendung.

Hinweis:
Ihr Computer zeigt für einige der Elemente der Visual Studio-Benutzeroberfläche in der folgenden Anleitung möglicherweise andere Namen oder Standorte an. Diese Elemente sind von der jeweiligen Visual Studio-Version und den verwendeten Einstellungen abhängig. Weitere Informationen finden Sie unter Visual Studio-Einstellungen.

So erstellen Sie das neue Windows-Anwendungsprojekt

1. Erstellen Sie im Menü Datei ein neues Projekt.

2. Nennen Sie das Projekt ORDesignerWalkthrough.

   Hinweis:
   Der O/R-Designer wird in Visual Basic- und C#-Projekten unterstützt. Erstellen Sie das neue Projekt daher in einer dieser Sprachen.

3. Klicken Sie auf die Vorlage Windows Forms-Anwendung und anschließend auf OK. Weitere Informationen finden Sie unter Erstellen von Windows-basierten Anwendungen.

   Das Projekt ORDesignerWalkthrough wird erstellt und dem Projektmappen-Explorer hinzugefügt.

Hinzufügen einer LINQ to SQL-Klassendatei zum Projekt (Öffnen des O/R-Designers)

Entitätsklassen werden in LINQ to SQL-Klassendateien (DBML-Dateien) erstellt und gespeichert. Der O/R-Designer wird geöffnet, wenn Sie eine DBML-Datei öffnen. Fügen Sie den Projekten DBML-Dateien hinzu, indem Sie im Dialogfeld Neues Element hinzufügen die Vorlage LINQ to SQL-Klassen auswählen.

So fügen Sie einem Projekt eine DBML-Datei hinzu

1. Klicken Sie im Menü Projekt auf Neues Element hinzufügen.

2. Klicken Sie auf die Vorlage LINQ to SQL-Klassen, und geben Sie im Feld Name den Namen Northwind.dbml ein.

3. Klicken Sie auf Hinzufügen.

   Dem Projekt wird eine leere LINQ to SQL-Klassendatei (Northwind.dbml) hinzugefügt, und der O/R-Designer wird geöffnet.

Nachdem Sie dem Projekt die neue LINQ to SQL-Datei hinzugefügt haben, wird die leere Entwurfsoberfläche geöffnet, auf der zwei separate Bereiche angezeigt werden. Der linke Bereich ist der Entitätenbereich, in dem die Entitätsklassen angezeigt und konfiguriert werden. Der Bereich rechts ist der Methodenbereich, in dem die DataContext-Methoden angezeigt werden, die dem Designer hinzugefügt werden. Wenn der Methodenbereich nicht angezeigt wird, klicken Sie mit der rechten Maustaste auf eine leere Stelle im Entitätenbereich, und klicken Sie auf Methodenbereich anzeigen. Die gesamte leere Oberfläche stellt einen konfigurierbaren DataContext dar. Der DataContext-Name entspricht dem Namen, den Sie für die DBML-Datei angegeben haben. In dieser exemplarischen Vorgehensweise ist NorthwindDataContext der Name des DataContext, da der LINQ to SQL-Datei der Name Northwind.dbml gegeben wurde. Sie können dies überprüfen, indem Sie im Designer auf einen leeren Bereich klicken und das Fenster Eigenschaften anzeigen.

Hinweis:
Die DataContext-Klasse enthält Methoden und Eigenschaften zum Herstellen einer Verbindung mit einer Datenbank und zum Ändern der Daten in dieser Datenbank, beispielsweise zum Einfügen, Aktualisieren und Löschen von Daten. Weitere Informationen finden Sie unter DataContext-Methoden (O/R-Designer).

Erstellen der Entitätsklassen Customer und Order

Erstellen Sie LINQ to SQL-Klassen, die Datenbanktabellen zugeordnet sind, indem Sie Tabellen von Server-Explorer/Datenbank-Explorer auf O/R-Designer ziehen. Das Ergebnis ist eine LINQ to SQL-Entitätsklasse, die der Tabelle in der Datenbank zugeordnet ist.

So fügen Sie dem O/R-Designer eine Customer-Entitätsklasse hinzu

1. Suchen Sie in Server-Explorer/Datenbank-Explorer die Tabellen in der SQL Server-Version der Beispieldatenbank Northwind. Weitere Informationen finden Sie unter Gewusst wie: Erstellen einer Datenverbindung mit der Northwind-Datenbank.

2. Ziehen Sie den Knoten Customers von Server-Explorer/Datenbank-Explorer auf die O/R-Designer-Oberfläche.

   Eine Entitätsklasse mit dem Namen Customer wird erstellt. Sie verfügt über Eigenschaften, die den Spalten in der Tabelle Customers entsprechen. Die Entitätsklasse wird Customer (nicht Customers) genannt, da sie einem einzelnen Kunden aus der Tabelle Customers entspricht.

   Hinweis:
   Dieses Umbenennungsverhalten wird als Pluralisierung bezeichnet. Es kann im Dialogfeld "Optionen" (Visual Studio) an- oder ausgeschaltet werden. Weitere Informationen finden Sie unter Gewusst wie: An- und Ausschalten der Pluralisierung (O/R-Designer).

3. Ziehen Sie den Knoten Orders von Server-Explorer/Datenbank-Explorer auf die O/R-Designer-Oberfläche.

   Eine Entitätsklasse Order mit einer Customer_Order-Zuordnung (Beziehung) zu der Entitätsklasse Customer wird erstellt. Sie verfügt über Eigenschaften, die den Spalten in der Tabelle Orders entsprechen.

   Hinweis:
   Die Entitätsklasse erhält den Namen Order, da sie eine einzelne Bestellung darstellt. Die übergeordnete Klasse (Customer) enthält die Eigenschaft Orders, die die Auflistung der Bestellungen für diesen bestimmten Kunden darstellt. Weitere Informationen über LINQ to SQL-Zuordnungen finden Sie unter Gewusst wie: Erstellen einer Zuordnung (Beziehung) zwischen LINQ to SQL-Klassen (O/R-Designer).

Erstellen einer Objektdatenquelle mit der Entitätsklasse Customer

Entitätsklassen können wie andere Klassen mit öffentlichen Eigenschaften als Objektdatenquellen dienen. Sie können dem Fenster Datenquellen hinzugefügt und auf Formulare gezogen werden, um datengebundene Steuerelemente zu erstellen (Steuerelemente, die an die Werte in den öffentlichen Eigenschaften des Objekts gebunden sind). Fügen Sie dem Fenster Datenquellen Entitätsklassen hinzu, indem Sie den Assistent zum Konfigurieren von Datenquellen ausführen und für die Datenquelle im Assistent auf Objekt klicken.

So fügen Sie Customer als Objektdatenquelle im Datenquellenfenster hinzu

1. Klicken Sie im Menü Erstellen auf ORDesignerWalkthrough erstellen, um das Projekt zu erstellen.

2. Klicken Sie im Menü Daten auf Datenquellen anzeigen.

3. Klicken Sie im Datenquellenfenster auf Neue Datenquelle hinzufügen.

4. Klicken Sie auf der Seite Datenquellentyp auswählen auf Objekt und anschließend auf Weiter.

5. Erweitern Sie den Knoten ORDesignerWalkthrough (den Knoten mit dem Namen Ihres Projekts), suchen Sie die Customer-Klasse, und wählen Sie diese aus.

   Hinweis:
   Wenn die Klasse Customer nicht verfügbar ist, beenden Sie den Assistenten, erstellen Sie das Projekt, und führen Sie den Assistenten erneut aus.

6. Klicken Sie auf Fertig stellen, um die Datenquelle zu erstellen, und fügen Sie die Entitätsklasse Customer zum Fenster Datenquellen hinzu.

Erstellen von datengebundenen Steuerelementen, um die Daten auf einem Windows Form anzuzeigen

Erstellen Sie Steuerelemente, die an Entitätsklassen gebunden sind, indem Sie LINQ to SQL-Datenquellenelemente vom Fenster Datenquellen auf ein Windows Form ziehen.

So fügen Sie Steuerelemente hinzu, die an die Entitätsklassen gebunden sind

1. Öffnen Sie Form1 in der Entwurfsansicht.

2. Ziehen Sie den Knoten Customer aus dem Fenster Datenquellen auf Form1.

   Hinweis:
   Klicken Sie im Menü Daten auf Datenquellen anzeigen, um das Fenster Datenquellen anzuzeigen.

3. Ziehen Sie den Knoten Orders aus dem Fenster Datenquellen auf Form1. Platzieren Sie ihn unter CustomerDataGridView.

4. Öffnen Sie Form1 in der Codeansicht.

5. Fügen Sie dem Formular den folgenden Code hinzu, sodass er global für das Formular gilt und außerhalb einer bestimmten Methode, jedoch innerhalb der Klasse Form1 steht:

   Private NorthwindDataContext1 As New NorthwindDataContext
   

   private NorthwindDataContext northwindDataContext1
       = new NorthwindDataContext();
   

6. Erstellen Sie einen Ereignishandler für das Form_Load-Ereignis, und fügen Sie dem Handler den folgenden Code hinzu:

   CustomerBindingSource.DataSource = NorthwindDataContext1.Customers
   

   customerBindingSource.DataSource
       = northwindDataContext1.Customers;
   

Testen der Anwendung

Führen Sie die Anwendung aus. Das Formular enthält nun eine DataGridView, die die Daten der Tabelle Customers anzeigt, sowie eine zweite DataGridView, die die Daten der ausgewählten Bestellungen des Kunden anzeigt.

Hinweis:
Beachten Sie, dass die Schaltfläche zum Speichern deaktiviert ist. (Die Speicherfunktionalität wird im nächsten Abschnitt implementiert.)

So testen Sie die Anwendung

1. Drücken Sie F5.

2. Überprüfen Sie, ob die Daten in den Rastern angezeigt werden.

3. Wählen Sie einen Kunden aus.

4. Überprüfen Sie, ob die angezeigten Bestellungen zum ausgewählten Kunden gehören.

5. Schließen Sie das Formular. (Klicken Sie im Menü Debuggen auf Debuggen beenden.)

Implementieren der Speicherfunktionalität

Wie bereits erwähnt, ist die Schaltfläche zum Speichern standardmäßig nicht aktiviert, und die Speicherfunktionalität ist nicht implementiert. Auch wird bei Erstellung datengebundener Steuerelemente für Objektdatenquellen nicht automatisch Code hinzugefügt, um geänderte Daten im Formular zu speichern. In diesem Abschnitt wird erklärt, wie die Schaltfläche zum Speichern aktiviert und die Speicherfunktionalität für LINQ to SQL-Objekte implementiert wird.

So implementieren Sie die Speicherfunktionalität

1. Öffnen Sie Form1 in der Entwurfsansicht.

2. Wählen Sie im CustomerBindingNavigator die Schaltfläche zum Speichern aus. (Die Schaltfläche ist mit einem Diskettensymbol gekennzeichnet.)

3. Legen Sie im Fenster Eigenschaften die Eigenschaft Aktiviert auf True fest.

4. Doppelklicken Sie auf die Schaltfläche zum Speichern, um einen Ereignishandler zu erstellen und zum Code-Editor zu wechseln.

5. Fügen Sie dem Ereignishandler für die Speichern-Schaltfläche den folgenden Code hinzu:

   Try
       NorthwindDataContext1.SubmitChanges()
   Catch ex As Exception
       MessageBox.Show(ex.Message)
   End Try
   

   try
   {
       northwindDataContext1.SubmitChanges();
   }
   catch (Exception ex)
   {
       MessageBox.Show(ex.Message);
   }
   

Testen der Anwendung

Führen Sie die Anwendung aus. Die Schaltfläche zum Speichern sollte nun aktiviert und die Datenspeicherungsoption verfügbar sein.

So testen Sie die Anwendung

1. Drücken Sie F5.

2. Ändern Sie einige Daten in einem der Raster. (Navigieren Sie von der bearbeiteten Zeile im Raster zu einer anderen Stelle, um einen Commit für prozessinterne Änderungen auszuführen.)

3. Klicken Sie auf die Speichern-Schaltfläche, um die Änderungen in der Datenbank zu speichern.

4. Schließen Sie das Formular.

5. Drücken Sie F5, und überprüfen Sie, ob die Änderungen beibehalten wurden, oder suchen Sie die Tabelle in der Datenbank, um zu überprüfen, ob die Änderungen gespeichert wurden.

Bindung an LINQ-Abfragen

Zusätzlich zum Herstellen einer Bindung der CustomerBindingSource an den DataContext können Sie auch direkt eine Bindung an LINQ-Abfragen herstellen. Weitere Informationen zum Erstellen von LINQ-Abfragen finden Sie unter Einführung in LINQ-Abfragen.

Hinzufügen eines Button und einer TextBox zum Formular

Um zu lernen, wie Steuerelemente an LINQ-Abfragen gebunden werden, fügen Sie dem Formular Steuerelemente hinzu, mit denen ein Abfrageparameter eingegeben und anschließend die Abfrage ausgeführt werden kann.

So fügen Sie dem Formular Steuerelemente hinzu

1. Öffnen Sie Form1 in der Entwurfsansicht.

2. Fügen Sie dem Formular eine TextBox hinzu, und legen Sie deren Name-Eigenschaft auf CityTextBox fest.

3. Fügen Sie dem Formular einen Button hinzu, und legen Sie die folgenden Eigenschaften fest:

   • Name = RunQueryButton

   • Text = Abfrage ausführen

Datenbindung an die LINQ-Abfrage

Fügen Sie Code hinzu, um eine LINQ-Abfrage auszuführen. Von der Abfrage wird der in CityTextBox als Abfrageparameter eingegebene Wert verwendet.

So stellen Sie eine Bindung an eine LINQ-Abfrage her

• Doppelklicken Sie auf RunQueryButton, und fügen Sie dem RunQueryButton_click-Ereignishandler den folgenden Code hinzu:

  Dim CustomersQuery = From customers in NorthwindDataContext1.Customers _
      Where customers.City = CityTextBox.Text _
      Select customers
  
  CustomerBindingSource.DataSource = CustomersQuery
  

  var CustomersQuery = from customers in northwindDataContext1.Customers
                        where customers.City == CityTextBox.Text
                        select customers;
  customerBindingSource.DataSource = CustomersQuery;
  

Testen der Anwendung

Führen Sie die Anwendung aus. Sie können jetzt Abfragen nach Kunden in einer bestimmten Stadt ausführen.

So testen Sie die Anwendung

1. Drücken Sie F5.

2. Geben Sie im Textfeld London ein.

3. Klicken Sie auf die Schaltfläche Abfrage ausführen.

4. Überprüfen Sie, ob nur die Kunden angezeigt werden, für die in der Eigenschaft City der Wert London angegeben wurde.

Überschreiben des Standardverhaltens für Aktualisierungen (Einfüge-, Aktualisierungs- und Löschvorgänge)

Standardmäßig wird die Logik für die Durchführung von Aktualisierungen von der LINQ to SQL-Laufzeit bereitgestellt. Von der Laufzeit werden Standardanweisungen zum Einfügen, Aktualisieren und Löschen auf der Grundlage der Select-Anweisung erstellt, die zum Füllen der Entitätsklasse mit Daten verwendet wird. Wenn Sie das Standardverhalten nicht verwenden möchten, können Sie das Aktualisierungsverhalten konfigurieren und für erforderliche Einfüge-, Aktualisierungs- und Löschvorgänge, die für das Bearbeiten der Daten in der Datenbank notwendig sind, spezielle gespeicherte Prozeduren festlegen. Diese Vorgehensweise ist auch dann sinnvoll, wenn kein Standardverhalten erzeugt wird, z. B. wenn die Entitätsklassen verknüpften Tabellen zugeordnet sind. Das Standardaktualisierungsverhalten kann auch dann überschrieben werden, wenn für die Datenbank der Tabellenzugriff über gespeicherte Prozeduren erforderlich ist.

Hinweis:
Für diesen Abschnitt ist es erforderlich, dass die zusätzlichen gespeicherten Prozeduren InsertCustomer, UpdateCustomer und DeleteCustomer für die Datenbank Northwind verfügbar sind. Ausführliche Informationen zum Erstellen dieser gespeicherten Prozeduren finden Sie unter Exemplarische Vorgehensweise: Erstellen von gespeicherten Prozeduren zum Aktualisieren der Northwind-Kundentabelle.

So überschreiben Sie das Standardaktualisierungsverhalten

1. Öffnen Sie im O/R-Designer die LINQ to SQL-Datei. (Doppelklicken Sie im Projektmappen-Explorer auf die Datei Northwind.dbml).

2. Erweitern Sie im Server-Explorer/Datenbank-Explorer für die Datenbank Northwind den Knoten Gespeicherte Prozeduren, und suchen Sie die gespeicherte Prozedur UpdateCustomers.

3. Ziehen Sie die gespeicherte Prozedur UpdateCustomers in den O/R-Designer.

   Die gespeicherte Prozedur UpdateCustomers wird dem Methodenbereich als eine DataContext-Methode hinzugefügt. Weitere Informationen finden Sie unter DataContext-Methoden (O/R-Designer).

4. Wählen Sie im O/R-Designer die Entitätsklasse Customer aus.

5. Wählen Sie im Fenster Eigenschaften den Befehl zum Überschreiben aus. ((Einfügen, Aktualisieren oder Löschen). Wählen Sie für dieses Beispiel die Eigenschaft Aktualisieren aus.

6. Klicken Sie auf die Auslassungszeichen neben Laufzeit verwenden, um das Dialogfeld Verhalten konfigurieren zu öffnen.

7. Wählen Sie Anpassen aus.

8. Wählen Sie in der Liste Anpassen die UpdateCustomers-Methode aus.

9. Überprüfen Sie die Liste der Methodenargumente und Klasseneigenschaften, und beachten Sie, dass für einige Spalten in der Tabelle zwei Methodenargumente sowie zwei Klasseneigenschaften vorhanden sind. Dies erleichtert das Nachverfolgen von Änderungen und das Erstellen von Anweisungen zur Überprüfung auf Parallelitätsverletzungen.

10. Ordnen Sie die ursprünglichen Methodenargumente (Original_ArgumentName) den ursprünglichen Eigenschaften (Eigenschaftsname (Original)) zu. Für diese exemplarische Vorgehensweise müssen Sie das Argument Original_CustomerID der Eigenschaft CustomerID (Original) zuordnen.

    Hinweis:

    Standardmäßig werden Klasseneigenschaften Methodenargumente zugeordnet, wenn die Namen übereinstimmen. Wenn Eigenschaftennamen geändert wurden und die Namen von Tabelle und Entitätsklasse nicht mehr übereinstimmen, kann es erforderlich sein, die entsprechende zuzuordnende Klasseneigenschaft auszuwählen, wenn die korrekte Zuordnung vom Designer nicht festgestellt werden kann. Wenn die Methodenargumente nicht über gültige Klasseneigenschaften für die Zuordnung verfügen, können Sie zusätzlich den Wert Klasseneigenschaften auf (Keine) festlegen.

11. Klicken Sie auf OK.

Testen der Anwendung

Führen Sie die Anwendung erneut aus, um zu überprüfen, ob der Kundendatensatz in der Datenbank von der gespeicherten Prozedur UpdateCustomers ordnungsgemäß aktualisiert wird.

So testen Sie die Anwendung

1. Drücken Sie F5.

2. Suchen Sie im Raster für ALFKI die Spalte ContactName.

3. Ändern Sie den Namen von Maria Anders in Anders.

4. Navigieren Sie aus der Zeile, um die Änderung zu übernehmen.

5. Klicken Sie auf die Schaltfläche zum Speichern.

6. Schließen Sie das Formular.

7. Drücken Sie F5, um die Anwendung erneut auszuführen, und überprüfen Sie, ob für ALFKI in der Spalte ContactName nur "Anders" angezeigt wird.

Nächste Schritte

Je nach den Anforderungen Ihrer Anwendung sollten Sie nach dem Erstellen von LINQ to SQL-Entitätsklassen mehrere Schritte ausführen. Zu den möglichen Verbesserungen, die Sie an dieser Anwendung vornehmen können, gehören die folgenden:

• Hinzufügen von weiteren gespeicherten Prozeduren, die für die Befehle zum Einfügen und Löschen verwendet werden können. Weitere Informationen finden Sie unter Gewusst wie: Zuweisen von gespeicherten Prozeduren zur Durchführung von Aktualisierungs-, Einfüge- und Löschvorgängen (O/R-Designer).

• Erstellen verschiedener LINQ-Abfragen, um gefilterte Daten zurückzugeben. Weitere Informationen finden Sie unter Gewusst wie: Abfragen von Informationen (LINQ to SQL).

Siehe auch

Konzepte

Übersicht über den O/R-Designer

Neue Datenfeatures

Referenz

Allgemeines LINQ-Programmierhandbuch

Weitere Ressourcen

Object Relational Designer (O/R-Designer)

LINQ to SQL

LINQ to ADO.NET

LINQ Documentation Roadmap

Zugreifen auf Daten (Visual Studio)