communityWir suchen ständig neue Tutorials und Artikel! Habt ihr selbst schonmal einen Artikel verfasst und seid bereit dieses Wissen mit der Community zu teilen? Oder würdet ihr gerne einmal über ein Thema schreiben das euch besonders auf dem Herzen liegt? Dann habt ihr nun die Gelegenheit eure Arbeit zu veröffentlichen und den Ruhm dafür zu ernten. Schreibt uns einfach eine Nachricht mit dem Betreff „Community Articles“ und helft mit das Angebot an guten Artikeln zu vergrößern. Als Autor werdet ihr für den internen Bereich freigeschaltet und könnt dort eurer literarischen Ader freien Lauf lassen.

Datenbankanwendungen mit Microsoft SQL Server Compact - LINQ to SQL Drucken E-Mail
Benutzerbewertung: / 142
SchwachPerfekt 
Samstag, den 12. September 2009 um 22:47 Uhr
Beitragsseiten
Datenbankanwendungen mit Microsoft SQL Server Compact
Datenbankentwurf
LINQ to SQL
Benutzeroberfläche
Alle Seiten

DataSet in Formular einbinden

Nachdem die Datenquelle angelegt ist, werden wir diese nun im Formular verwenden. In Visual Studio lässt sich eine Steuerung direkt mit jeder Spalte aus der Datenbank verknüpfen, indem die entsprechende Spalte aus der Tabelle oder die gesamte Tabelle selbst auf das Formular gezogen wird. Auf diese Weise können Sie den Benutzer über die GUI direkt die Datenbank manipulieren lassen.

Es gibt prinzipiell zwei Varianten eine Tabelle auf ein Formular zu bringen. Sie können die Tabelle direkt einfügen, diese wird dann vollständig als DataGridView angezeigt, oder Sie klicken die Tabelle an und wählen in der Dropdownliste die Option Details. In diesem Fall wird für jede Spalte eine individuelle Control generiert. Wir wollen ein Formular erstellen, in dem der Benutzer neue Kunden in die Datenbank aufnehmen kann.

  • Öffnen Sie das Formular im Designmodus. Das Formular ist jetzt noch vollständig leer.
  • Öffnen Sie das Datenquellenfenster.
  • Klicken Sie nun in der Dropdownliste der Tabelle „Kunden“ die Option Details an.
  • Ziehen Sie die Tabelle „Kunden“ aus dem Datenquellenfenster in das Formular.

Die Entwicklungsumgebung hat für Sie nun alle Steuerelemente erstellt und eine Navigationsleiste eingefügt. Mit der Navigationsleiste können Sie über die Einträge in der Datenbank iterieren, neue Einträge erstellen, diese löschen und abspeichern. Der BindingNavigator wird als Objekt unter dem Formular angezeigt. Gleichzeitig wurden weitere Elemente an die Datenquelle gebunden.

kundenformular
Datenbindung

Die Datenbindung verbindet eine Datenquelle, z.B. eine DataTable, mit einem Datenverbraucher, z.B. die DataGridView oder eine einfache Textbox. Über die Datenbindung werden die Daten zwischen der Datenquelle und dem Datenverbraucher in beiden Richtungen ausgetauscht. Der Datenfluss wird durch mehrere Klassen geregelt. Auf diesen Datenfluss können Sie über Klasseneigenschaften und auch über Ereignisse Einfluss nehmen und z.B. Formatierungen vorgeben.

Die einfache Datenbindung bezeichnet die Bindung einer Eigenschaft eines Steuerelements an ein einziges Datenelement (eine Spalte in einem Datensatz). In der Regel können mehrere Eigenschaften eines Steuerlements an ein Datenelement gebunden werden. Für eine Textbox oder ein Label wird in der Regel die Text-Eigenschaft angebunden. Es ist aber auch möglich, z.B. die Readonly-Eigenschaft der Textbox an eine Spalte anzubinden, die einen boolschen Wert besitzt.

Bei der komplexen Bindung werden mehrere Datensätze gebunden. Die DataGridView und die Listbox sind zwei Beispiele für Steuerelemente, die eine komplexe Bindung unterstützen.

Datensätze einfügen

Die Tabelle „Kunden“ besitzt keine Fremdschlüsselabhängigkeit, so dass problemlos Datensätze eingefügt werden können. Starten Sie nun mit F5 den Kompiliervorgang und führen Sie die Anwendung aus. Sie müssten nun das erstellte Formular sehen können. Fügen Sie Beispieldaten ein und speichern sie diese oben in der Navigationsleiste mit dem Diskettensymbol ab. Die Anwendung speichert die Daten nun automatisch in der SQL CE-Datenbank. Geben Sie weitere Datensätze an, indem Sie das Plussymbol anklicken und einen neuen Datensatz eingeben. Speichern Sie anschließend erneut ab. Sie können nun über die Navigationsleiste zwischen den erstellten Datensätzen hin und her wechseln.

Wenn Sie die Anwendung beenden und neu starten, werden Sie sehen das alle Datensätze existent bleiben. Sie wurden in der Datenbank shop.sdf hinterlegt. Damit haben Sie ihre erste kleine Datenbankanwendung erfolgreich entwickelt.

Nun ist die bisherige Anwendung bereits brauchbar, wenn es darum geht Datensätze persistent abzuspeichern, aber für einen Shop fehlen noch einige elementare Dinge. So sollte der Nutzer bequem neue Bestellungen aufnehmen können, diese bei Bedarf einsehen und auch sortieren ohne sich durch die Datenbanktabellen hangeln zu müssen. Wir möchten deshalb nun einige nützliche Formulare schreiben, die es dem Nutzer ermöglichen mit den Daten sinnvoll zu arbeiten. Die Grundlage der Bearbeitung von Datensätzen in Datenbanken ist die SQL. Neben dieser klassischen Methode über die ADO.NET-Klassen (Connection, Command und DataReader) gibt es seit .NET 3.5 die Möglichkeit LINQ zu nutzen. Im nächsten Kapitel erfahren Sie dazu mehr.

LINQ

LINQ (Abkürzung für Language INtegrated Query) ist eine Komponente von Microsofts .NET-Framework zur Abfrage von Datenquellen wie Datenbanken oder XML-Dateien. Besonderheit ist, dass SQL-, XLink- und XQuery-Anfragen direkt in .NET-Programmiersprachen wie C# 3.0 oder VB.Net 9.0 als Code statt als String eingebunden werden können. LINQ wurde federführend von Turbo-Pascal- und C#-Autor Anders Hejlsberg entwickelt.

Der Vorteil von LINQ besteht darin, dass der Code durch den Compiler auf Fehler geprüft und optimiert werden kann. Die Syntax von LINQ ist dabei an den Befehlen der SQL-Anfragesprache wie „select“, „from“ und „where“ angelehnt. Die Befehle werden jedoch nicht in SQL-Code umgewandelt, sondern sprechen, mit Hilfe der im .NET-Framework 3.5 eingeführten Erweiterungen, direkt .NET-Objekte an, welche die gewünschte Operation ausführen. Diese Objekte müssen die Schnittstelle IEnumerable implementieren.

Mehr über LINQ erfahren Sie auf unserer Homepage in dem Artikel „C# und LINQ“.

LINQ to SQL

In LINQ to SQL wird eine Linq-Abfrage zu einem SQL-Statement umgewandelt. Dieses Statement ist für MS SQL Server ausgelegt. Da SQL Server die Daten relational speichert und Linq mit Datenkapselung arbeitet, müssen die Objekte „gemappt“ werden.

Visual Studio 2008 unterstützt LINQ to SQL in Verbindung mit SQL Server Compact nicht. Allerdings wird es vom .NET-Framework unterstützt, so dass es problemlos möglich ist LINQ zu verwenden. Es gibt sogar einen Trick, wie man Visual Studio 2008 dazu bewegen kann die erforderlichen Dateien zu generieren. Sie benötigen dazu lediglich das Tool SqlMetal.exe, welches im Windows SDK enthalten ist und die automatische Codegenerierung von Wrapper-Klassen für Microsoft SQL Server-Datenbanken in C# mit DLINQ ermöglicht.

  • Kopieren Sie die sdf-Datenbankdatei in dasselbe Verzeichnis, in dem sich auch SqlMetal.exe befindet.
  • Starten Sie mit Start | Ausführen | Cmd die Konsole als Administrator.
  • Wechseln Sie nun in der Konsole mit cd C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\ in das Verzeichnis von SqlMetal.exe.
  • Führen Sie das Tool mit SqlMetal.exe shop.sdf /dbml:ShopDatabase.dbml aus.
  • Kopieren Sie nun die erzeugte Datei ShopDatabase.dbml in das Projektverzeichnis.
  • Fügen Sie die Datei nun Ihrem Projekt hinzu.

Sobald die Datei *.dbml hinzugefügt wurde, generiert Visual Studio 2008 automatisch den .NET Code (C# oder VB.NET) für die System.Data.Linq.DataContext Klasse, die Sie verwenden werden um auf die Daten zuzugreifen.

namespace Shop
{
    using System.Data.Linq;
    using System.Data.Linq.Mapping;
    using System.Data;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Linq;
    using System.Linq.Expressions;
    using System.ComponentModel;
    using System;
 
 
    [System.Data.Linq.Mapping.DatabaseAttribute(Name="shop")]
    public partial class ShopDatabase : System.Data.Linq.DataContext
    {    
        private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();
        // ...
 

Achten Sie darauf das es beim Import nicht zu Namenskonflikten kommt. Der Designer generiert automatisch eine partielle Klasse, die den Namen, der in der Datei *.dbml spezifiziert wurde, trägt. Falls ihr Projekt in dem Namensraum Shop eingebettet wurde, sollte die partielle Klasse nicht denselben Namen tragen, da es sonst zu Auflösungsproblemen kommen kann. Der Compiler kann dann nicht mehr zwischen der Klasse und dem Namensraum sauber unterscheiden. In dem Codeabschnitt oben wurde der Name der partiellen Klasse deshalb in ShopDatabase abgeändert. Sie können den Namen auch vor dem Import in der Datei ShopDatabase.dbml anpassen.

Nun können Sie die Datei ShopDatabase.dbml in der Entwicklungsumgebung anklicken. Visual Studio 2008 zeigt Ihnen, wie bei dem DataSet, ein vollständiges Datenbankdiagramm an, diesmal ein Abbild der LINQ Wrapper-Klassen. Sie können das Diagramm anklicken und sich auch die Spalteneigenschaften im Detail anzeigen lassen.

linq_datenbankdiagramm
Beispiele

In einigen kurzen Beispielcodes soll die Funktionsweise von LINQ erläutert werden. Wir möchten den Wohnort einer Kundin mit dem Namen "Vogel" in Hamburg abändern.

string name = "Vogel";
var kunde = db.Kunden.Single(k => k.Name == name);
kunde.Ort = "Hamburg";
 
// Submit the change to the database.
try {
    db.SubmitChanges();
} catch (Exception ex) {
 
}

An dieser Stelle können Sie auch den Einsatz sogenannter Lambda-Ausdrücke sehen. Möchten Sie alle Kunden mit gerader Kundennummer auslesen, so können Sie eine SQL ähnliche Anweisung verwenden.

var q =
   from k in db.Kunden
   where k.Kundennr % 2 == 0
   select k;
 
foreach (Kunden kunden in q) {
    textBox1.Text += kunden.Name + "\r\n";
}

Oder Sie nutzen das Lambda-Kalkül.

var q = db.Kunden.Where(k => k.Kundennr % 2 == 0);

Lassen Sie uns nun alle Vornamen von Kunden ausgeben, die in Berlin wohnhaft sind.

var q = from k in db.Kunden
        where k.Ort == "Berlin"
        select k;
 
foreach (Kunden kunden in q) {
    textBox1.Text = kunden.Vorname  + "\r\n";
}

Ein neuer Kunde kann explizit mit der folgenden Anweisung erstellt werden.

// Create a new Kunden object.
Kunden kunden = new Kunden {
    Kundennr = 5,    // Set only, if column not identity
    Name = "Walter",
    Vorname = "Gustav",
    PLZ = 20654,
    Ort = "Hamburg",
    Strasse = "Elisenstrasse",
    Hausnr = 1
};
 
// Add the new object to the Orders collection.
db.Kunden.InsertOnSubmit(kunden);
 
// Submit the change to the database.
try {
    db.SubmitChanges();
} catch (Exception ex) {
 
}

Einzelne Zeilen in einer Tabelle lassen sich mit Count zählen.

int c = db.Kunden.Count();

Will man die höchste ID eines Primärschlüssels in Erfahrung bringen, so verwendet man Max.

int max = (from k in db.Kunden select k.Kundennr).Max();

Möchte man die Daten sortiert ausgeben, so erreicht man das mit dem Schlüsselwort orderby, welches der SQL-Anweisung ORDER BY entspricht. Gleichzeitig kann mit Take, ähnlich wie in SQL mit LIMIT, die Anzahl der Zeilen eingegrenzt werden.

var q = (from k in db.Kunden orderby k.Vorname select k).Take(2);
 
foreach (Kunden kunden in q) {
    textBox1.Text += kunden.Vorname + "\r\n";
}

Desweiteren ist es möglich Take mit Skip zu kombinieren. Auf diese Weise werden die ersten drei Zeilen übersprungen.

var q = (from k in db.Kunden orderby k.Vorname select k).Skip(3).Take(2);
 
foreach (Kunden kunden in q) {
    textBox1.Text += kunden.Vorname + "\r\n";
}

Die nächste Codezeile wählt alle Kunden mit einer Kundennummer kleiner 50 aus und sortiert das Ergebnis alphabetisch nach den Namen.

var q = db.Kunden.Where(k => k.Kundennr < 50).OrderBy(k => k.Name);

Oftmals sollen neue Collections gebildet werden. Das erreichen Sie mit der folgenden Anweisung.

var q =
    from k in db.Kunden
    select new { k.Vorname, k.Ort };
 
foreach (var v in q) {
    textBox1.Text += v.Ort + " " + v.Vorname + "\r\n";
}

Der Join ist auch in LINQ eine wichtige Anweisung, um Tabellen miteinander zu verknüpfen. Der folgende Code ermittelt alle von Frau Vogel bestellten Artikel und gibt diese sortiert aus.

var q =
   from k in db.Kunden
   join b in db.Bestellungen on k.Kundennr equals b.Kundennr
   join n in db.Enthaelt on b.Bestellnr equals n.Bestellnr
   join a in db.Artikel on n.Artikelnr equals a.Artikelnr
   where k.Name == "Vogel"
   orderby a.Bezeichnung
   select a;
 
foreach (Artikel art in q) {
    textBox1.Text += art.Bezeichnung + "\r\n";
}
 

Ein Group Join lässt sich mit dem Schlüsselwort into realisieren.

var q =
   from k in db.Kunden
   join b in db.Bestellungen on k.Kundennr equals b.Kundennr into sbest
   select new { k, sbest };

Auf den Seiten des Microsoft Developer Network (MSDN) stellt das Softwareunternehmen unter dem Titel "101 LINQ Samples" viele weitere Beispiele zur Verfügung.

Wenn Sie neu in der Welt von LINQ sind, können Sie sich das kostenlose Tool LINQPad herunterladen. Es eignet sich besonders gut zum Erlernen von LINQ to SQL.

LINQ gewährt dem Programmierer einen angenehmen Weg direkt in der Programmiersprache auf Daten in einer Datenbank zuzugreifen, diese zu verändern oder sogar zu löschen. Neben der Handhabung ist auch die Fehlerreduktion sehr hilfreich, da im Gegensatz zu einer SQL-Anweisung (Zeichenfolge) bei LINQ eine Prüfung der Syntax durch den Compiler erfolgt. Dessen ungeachtet wollen wir uns nun auch mit den ADO.NET-Klassen und SQL befassen.

SQL

Die Structured Query Language, kurz SQL, ist eine Datenbanksprache zur Definition, Abfrage und Manipulation von Daten in relationalen Datenbanken. SQL ist von ANSI und ISO standardisiert und wird von fast allen gängigen Datenbanksystemen unterstützt.

Die Syntax von SQL ist relativ einfach aufgebaut und semantisch an die englische Umgangssprache angelehnt. SQL stellt eine Reihe von Befehlen zur Definition von Datenstrukturen nach der relationalen Algebra, zur Manipulation von Datenbeständen (Einfügen, Bearbeiten und Löschen von Datensätzen) und zur Abfrage von Daten zur Verfügung. Durch seine Rolle als Quasi-Standard ist SQL von großer Bedeutung, da eine weitgehende Unabhängigkeit von der benutzten Software erzielt werden kann.

Datenprovider verwenden

Auf Datenbanken in .NET wird mit dem .NET-Datenprovider aus ADO.NET zugegriffen. Für Microsoft SQL Server Compact stehen selbstverständlich ebenfalls Provider zur Verfügung, die Sie auch ohne Umwege ansprechen können. Im Gegensatz zu LINQ werden keine Wrapper-Klassen benötigt. In diesem Kapitel werden Sie mit dem Umgang der wichtigen Klassen Connection, Command, DataReader und DataAdapter vertraut gemacht.

Connection

Die Connection-Klasse (Connection) ist eine relativ einfache Klasse unter den ADO.NET-Klassen. Sie stellt eine Verbindung zu einer Datenbank her und wird bei allen Datenbankzugriffen verwendet. Bei SQL CE heißt die Klasse SqlCeConnection.

Command

Nachdem Sie eine Verbindung zur Datenbank aufgebaut haben, können Sie ein Command-Objekt dazu verwenden, die Daten in der Datenbank zu verändern und/oder auszulesen. Die Command-Klasse kapselt eine Anweisung an die Datenbank. Ein Command repräsentiert eine SQL-Anweisung oder eine gespeicherte Prozedur, die ausgeführt werden soll, und enthält zusätzliche Informationen und Parameter für die Datenbank. Jede Datenbankoperation wird über ein Command ausgeführt.

Die folgende Datenbankabfrage gibt alle von Frau Vogel bestellten Artikel zurück. Die Artikelbezeichnung wird anschließend in einer TextBox ausgegeben.

SqlCeConnection conn = new SqlCeConnection(connString);
SqlCeCommand cmd = null;
SqlCeDataReader rdr = null;
 
try {
 
    conn.Open();
 
    cmd = conn.CreateCommand();
 
    cmd.CommandText = "SELECT * " +
                      "FROM Artikel a " + 
                      "INNER JOIN Enthaelt n " +
                      "    ON a.Artikelnr = n.Artikelnr " +
                      "INNER JOIN Bestellungen b " +
                      "    ON n.Bestellnr = b.Bestellnr " +
                      "INNER JOIN Kunden k " +
                      "    ON b.Kundennr = k.Kundennr " +
                      "WHERE k.Name = 'Vogel' " +
                      "ORDER BY a.Bezeichnung;";
 
    rdr = cmd.ExecuteReader();
 
    while (rdr.Read()) {                  
        int artikelnr = rdr.GetInt32(0);                  
        string bezeichnung = rdr.GetString(1);
        decimal preis = rdr.GetDecimal(2);
        int herstellernr = rdr.GetInt32(3);
 
        textBox1.Text += bezeichnung + "\r\n";
    }
 
} catch (SqlCeException ex) {
    MessageBox.Show(ex.Message);
} catch (Exception ex) {
    MessageBox.Show(ex.Message);
} finally {
    rdr.Close();
    conn.Close();
}

Das gezeigte Beispiel ist ein exaktes Gegenstück zu der zuvor gezeigten LINQ-Anweisung.

DataReader

Der DataReader stellt ein Verfahren zum streng vorwärts gerichteten Lesen von Datensätzen aus einer Datenbank bereit. Der DataReader stellt eine ganze Fülle von Methoden zur Verfügung, um Spaltenwerte auszulesen, nämlich für jeden erdenklichen .NET-Datentyp eine. Für die SqlCeDataReader-Klasse sind es noch mehr, hier kommen die Get-Methoden für alle SQL Server Compact-Datentypen hinzu.

Die Methoden sind alle nach ihrem speziellen Datentyp, den sie zurückgeben, benannt, z.B. GetBoolean, GetDateTime, GetString etc. Wenn Sie diese Methoden verwenden, müssen sie ganz genau wissen, welchen Datentyp Sie erhalten. Dies wird auch dadurch erschwert, dass Methoden die Identifizierung der Spalte nur über deren Index (Position) zulassen. Der DataReader stellt summa summarum sehr primitive Methoden bereit, um mit den Datensätzen zu arbeiten.

DataAdapter

Der DataAdapter ist die wichtigste Klasse der .NET Data Provider. Mit ihm können Sie Ihren lokalen Datenspeicher füllen und Änderungen in die Datenbank zurückspeichern. Sie brauchen im Wesentlichen nur eine einzige Methode, um die Daten aus der Datenbank zu laden, und eine weitere Methode, um die Änderungen an den Daten wieder zurückzuspeichern. Der DataAdapter nutzt dabei intern weitere Klassen, die Sie entweder über den Designer oder über eigenen Programmcode erzeugen können.

Der DataAdapter arbeitet direkt mit dem lokalen Datenspeicher zusammen. Er füllt immer eine oder mehrere Tabellen ( DataTable-Objekte), entsprechend der Anzahl der Ergebnismengen des SelectCommands. Der Adapter fungiert als Brücke zwischen lokalen Datenspeicher und der Datenbank. Damit der DataAdapter Daten aus der Datenbank in den lokalen Datenspeicher laden kann, müssen einige Kriterien erfüllt sein. So muss ein DataTable-Objekt oder ein DataSet existieren. Weiterhin benötigen Sie ein Connection-Objekt und ausformulierte SQL-Abfragen. Zum Schluss muss der DataAdapter selbst erzeugt werden.

Sie haben bereits intensive Bekanntschaft mit der DataAdapter-Klasse gemacht, als Sie das DataSet generierten. In der vom Designer erzeugten Datei shopDataSet.Designer.cs finden Sie den DataAdapter für die SQL Server Compact-Datenbank, er nennt sich SqlCeDataAdapter. Der Designer hat nicht nur für jede Tabelle in der Datenbank einen Adapter erstellt und die Klassen SqlCeConnection, SqlCeCommand und SqlCeTransaction erzeugt, er hat auch alle Insert-, Update- und DeleteCommand-Objekte generiert. Gleichzeitig wurde für jede Tabelle auch das entsprechende DataTable-Objekt erstellt.

/// <summary>
///Represents the connection and commands used to retrieve and save data.
///</summary>
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
[global::System.ComponentModel.DesignerCategoryAttribute("code")]
[global::System.ComponentModel.ToolboxItem(true)]
[global::System.ComponentModel.DataObjectAttribute(true)]
[global::System.ComponentModel.DesignerAttribute("Microsoft.VSDesigner.DataSource.Design.TableAdapterDesigner, Microsoft.VSDesigner" +
    ", Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
[global::System.ComponentModel.Design.HelpKeywordAttribute("vs.data.TableAdapter")]
public partial class KundenTableAdapter : global::System.ComponentModel.Component {
 
    private global::System.Data.SqlServerCe.SqlCeDataAdapter _adapter;
 
    private global::System.Data.SqlServerCe.SqlCeConnection _connection;
 
    private global::System.Data.SqlServerCe.SqlCeTransaction _transaction;
 
    private global::System.Data.SqlServerCe.SqlCeCommand[] _commandCollection;
 
    private bool _clearBeforeFill;
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public KundenTableAdapter() {
        this.ClearBeforeFill = true;
    }   
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    private void InitAdapter() {
        this._adapter = new global::System.Data.SqlServerCe.SqlCeDataAdapter();
        global::System.Data.Common.DataTableMapping tableMapping = new global::System.Data.Common.DataTableMapping();
        tableMapping.SourceTable = "Table";
        tableMapping.DataSetTable = "Kunden";
        tableMapping.ColumnMappings.Add("Kundennr", "Kundennr");
        tableMapping.ColumnMappings.Add("Name", "Name");
        tableMapping.ColumnMappings.Add("Vorname", "Vorname");
        tableMapping.ColumnMappings.Add("PLZ", "PLZ");
        tableMapping.ColumnMappings.Add("Ort", "Ort");
        tableMapping.ColumnMappings.Add("Strasse", "Strasse");
        tableMapping.ColumnMappings.Add("Hausnr", "Hausnr");
        this._adapter.TableMappings.Add(tableMapping);
        this._adapter.DeleteCommand = new global::System.Data.SqlServerCe.SqlCeCommand();
        this._adapter.DeleteCommand.Connection = this.Connection;
        this._adapter.DeleteCommand.CommandText = "DELETE FROM [Kunden] WHERE (([Kundennr] = @p1))";
        this._adapter.DeleteCommand.CommandType = global::System.Data.CommandType.Text;
        this._adapter.DeleteCommand.Parameters.Add(new global::System.Data.SqlServerCe.SqlCeParameter("@p1", global::System.Data.SqlDbType.Int, 0, global::System.Data.ParameterDirection.Input, true, 0, 0, "Kundennr", global::System.Data.DataRowVersion.Original, null));
        this._adapter.InsertCommand = new global::System.Data.SqlServerCe.SqlCeCommand();
        this._adapter.InsertCommand.Connection = this.Connection;
        this._adapter.InsertCommand.CommandText = "INSERT INTO [Kunden] ([Kundennr], [Name], [Vorname], [PLZ], [Ort], [Strasse], [Ha" +
            "usnr]) VALUES (@p1, @p2, @p3, @p4, @p5, @p6, @p7)";
        // ...

Der DataAdapter wird nicht als allein stehendes Objekt erzeugt, sondern zusammen mit den Command-Objekten in einem speziellen TableAdapter-Objekt zusammengefasst. Der TableAdapter ist eine neue Klasse, die allerdings nur in einer typisierten Form innerhalb des typisierten DataSets existiert. Der TableAdapter leitet sich direkt von System.ComponentModel.Component ab und enthält alle wesentlichen Objekte. Vor der Verwendung des TableAdapters muss dieser initialisiert werden. Das geschieht mit der Fill-Methode.

theTableAdapter.Fill(myDataSet.myTable);

Durch die vom Designer automatisch erstellten TableAdapter-Objekte können Sie in Ihrer Anwendung bequem mit dem DataSet arbeiten, die Kommunikation mit der Datenbank findet im Hintergrund über die Adapter-Klassen statt.



Zuletzt aktualisiert am Freitag, den 14. Januar 2011 um 09:13 Uhr
 
AUSWAHLMENÜ