Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort zur 5. Auflage
1 Allgemeine Einführung in .NET
2 Grundlagen der Sprache C#
3 Klassendesign
4 Vererbung, Polymorphie und Interfaces
5 Delegates und Ereignisse
6 Weitere .NET-Datentypen
7 Weitere Möglichkeiten von C#
8 Auflistungsklassen (Collections)
9 Fehlerbehandlung und Debugging
10 LINQ to Objects
11 Multithreading und die Task Parallel Library (TPL)
12 Arbeiten mit Dateien und Streams
13 Binäre Serialisierung
14 Einige wichtige .NET-Klassen
15 Projektmanagement und Visual Studio 2010
16 XML
17 WPF – Die Grundlagen
18 WPF-Containerelemente
19 WPF-Steuerelemente
20 Konzepte der WPF
21 Datenbindung
22 2D-Grafik
23 ADO.NET – verbindungsorientierte Objekte
24 ADO.NET – Das Command-Objekt
25 ADO.NET – Der SqlDataAdapter
26 ADO.NET – Daten im lokalen Speicher
27 ADO.NET – Aktualisieren der Datenbank
28 Stark typisierte DataSets
29 LINQ to SQL
30 Weitergabe von Anwendungen
Stichwort

Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Visual C# 2010 von Andreas Kühnel
Das umfassende Handbuch
Buch: Visual C# 2010

Visual C# 2010
geb., mit DVD
1295 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1552-7
Pfeil 27 ADO.NET – Aktualisieren der Datenbank
Pfeil 27.1 Aktualisieren mit dem »CommandBuilder«
Pfeil 27.1.1 Von »SqlCommandBuilder« generierte Aktualisierungsstatements
Pfeil 27.1.2 Konfliktsteuerung in einer Mehrbenutzerumgebung
Pfeil 27.1.3 Die Eigenschaft »ConflictOption« des »SqlCommandBuilder«
Pfeil 27.1.4 Die Eigenschaft »SetAllValues«
Pfeil 27.2 Manuell gesteuerte Aktualisierung
Pfeil 27.2.1 Eigene Aktualisierungslogik
Pfeil 27.2.2 Beispielprogramm
Pfeil 27.3 Konfliktanalyse
Pfeil 27.3.1 Benutzer über fehlgeschlagene Aktualisierungen informieren
Pfeil 27.3.2 Konfliktverursachende Datenzeilen bei der Datenbank abfragen
Pfeil 27.4 Neue Autoinkrementwerte abrufen


Galileo Computing - Zum Seitenanfang

27.2 Manuell gesteuerte Aktualisierung Zur nächsten ÜberschriftZur vorigen Überschrift

Mit komplexen Aktualisierungsszenarien kann der SqlCommandBuilder nicht umgehen. Er scheidet in solchen Fällen aus und muss durch manuellen Aktualisierungscode ersetzt werden. Wir können dazu durchaus auf das SqlDataAdapter-Objekt und dessen Update-Methode zurückgreifen. Den Aktualisierungscode, den uns in einfacheren Umgebungen der SqlCommandBuilder zur Verfügung stellt, müssen wir allerdings selbst schreiben.

Grundsätzlich ist bei der Aktualisierung mit der Update-Methode des SqlDataAdapters entscheidend, dass die Eigenschaften

  • UpdateCommand
  • InsertCommand
  • DeleteCommand

des SqlDataAdapters ein passendes SqlCommand-Objekt beschreiben. Die Update-Methode arbeitet im Grunde genommen sehr einfach. Sie sucht in einem DataSet bzw. in der DataTable nach den Datenzeilen, deren DataRowState nicht Unchanged ist. Trifft die Methode auf eine in welcher Weise auch immer geänderte Datenzeile, greift sie auf ein entsprechendes Command-Objekt zurück, weist die entsprechenden Parameter zu und setzt die Änderung ab.

Der entscheidende Punkt ist, dass der DataAdapter sich nicht dafür interessiert, wie das Command-Objekt gestaltet ist und aus welcher Quelle es stammt. Wichtig ist ihm nur, dass ein gültiges Command-Objekt vorliegt. Damit haben wir auch schon den ersten Ansatz gefunden. Wir stellen eigene Command-Objekte zur Verfügung – nennen wir sie updateCommand, deleteCommand und insertCommand – und weisen sie den entsprechenden Eigenschaften des DataAdapters zu:


<SqlDataAdapter>.UpdateCommand = updateCommand;
<SqlDataAdapter>.InsertCommand = insertCommand;
<SqlDataAdapter>.DeleteCommand = deleteCommand;

Alle drei Eigenschaften sind vom Typ SqlCommand. Ein Command-Objekt kennt durch seine Eigenschaft CommandText das SQL-Kommando, das gegen die Datenbank abgesetzt werden soll. Damit sind alle Forderungen erfüllt, die die Methode Update des DataAdapters stellt.

Etwas erleichtern können wir uns das manuelle Aktualisieren, wenn wir daran denken, dass meistens keine besonderen Anforderungen sowohl hinsichtlich des Einfügens einer neuen Datenzeile als auch hinsichtlich des Löschens einer Datenzeile gestellt werden. Hier leistet der SqlCommandBuilder dann oft sehr gute Dienste, um das entsprechende INSERT- und DELETE-Statement zu erzeugen. Sie müssen in diesen Fällen nur ein SqlCommand-Objekt bereitstellen, das den Aktualisierungsanforderungen an eine geänderte Datenzeile entspricht, und dieses der Eigenschaft UpdateCommand des SqlDataAdapters übergeben.


Galileo Computing - Zum Seitenanfang

27.2.1 Eigene Aktualisierungslogik Zur nächsten ÜberschriftZur vorigen Überschrift

Den Ausführungen in diesem Abschnitt liegt das folgende SQL-Statement zugrunde:


SELECT ProductID, ProductName, Unitprice, UnitsInStock, Discontinued 
FROM Products

Sehen wir uns nun die Methode an, die für das Erzeugen des Kommandos zum Absetzen einer Datenzeilenänderung verantwortlich ist. Auch bei dieser Methode sei angenommen, dass zwischenzeitliche Änderungen durch andere Benutzer bei der Aktualisierung überschrieben werden. Dabei sei gefordert, dass etwaige Änderungen eines anderen Benutzers in der Spalte ProductName und UnitPrice nicht akzeptiert werden können und zu einem Konflikt führen sollen. Im Suchkriterium sind daher die Angabe des Primärschlüssels sowie die Angabe des Originalwertes der Spalten ProductName und UnitPrice erforderlich.


static SqlCommand CreateUpdateCommand(SqlConnection con) {
  string sql = "UPDATE Products SET ProductName=@p1, UnitPrice=@p2,
  		UnitsInStock=@p3 WHERE ProductID=@p4 AND
		ProductName= @p5 AND UnitPrice=@p6";
  SqlCommand cmd = new SqlCommand(sql, con);
  cmd.Parameters.Add("@p1", SqlDbType.VarChar, 40, "ProductName");
  cmd.Parameters.Add("@p2", SqlDbType.Money, 8, "UnitPrice");
  cmd.Parameters.Add("@p3", SqlDbType.SmallInt, 2, "UnitsInStock");
  cmd.Parameters.Add("@p4", SqlDbType.Int, 4, "ProductID");
  SqlParameter param;
  param = cmd.Parameters.Add("@p5", SqlDbType.VarChar, 40, "ProductName");
  param.SourceVersion = DataRowVersion.Original;
  param = cmd.Parameters.Add("@p6", SqlDbType.Money, 8, "UnitPrice");
  param.SourceVersion = DataRowVersion.Original;
  return cmd
}

Wird der DataAdapter zur Aktualisierung eingesetzt, muss jedem Parameter mitgeteilt werden, aus welcher Spalte der zu editierenden DataRow der Wert für den betreffenden Parameter abgerufen werden soll, beispielsweise:


cmd.Parameters.Add("@p1", SqlDbType.VarChar, 40, "ProductName");

Hier teilen wir dem Parameter mit, dass er den Wert aus der Spalte ProductName beziehen soll. Standardmäßig wird der Wert aus DataRowVersion.Current bezogen. Vergessen Sie die Angabe des vierten Parameters, kann der DataAdapter die Datenzeile nicht an die Datenbank übermitteln. Haben Sie eine explizite Referenz auf den Parameter, können Sie die Spalte auch der Eigenschaft SourceColumn bekanntgeben.

Die Parameter der Suchkriterien benötigen den Originalwert, um die betreffende Datenzeile in der Tabelle der Datenbank aufzuspüren. Damit der DataAdapter die erforderlichen Werte aus DataRowVersion.Original einträgt, teilen Sie das dem Parameter in seiner Eigenschaft SourceVersion mit:

param.SourceVersion = DataRowVersion.Original;

Das auf diese Weise in der Methode erzeugte Command-Objekt wird an den Aufrufer zurückgeliefert. Wie Sie weiter oben schon gesehen haben, weisen wir dessen Referenz der Eigenschaft UpdateCommand des DataAdapters zu, der automatisch die Parameter füllt, wenn er auf eine geänderte Datenzeile trifft.


Anmerkung

Die Primärschlüsselspalte ProductID stellt hierbei in der Tabelle Products einen Sonderfall dar, da sie als Autoinkrement-Spalte definiert ist und somit grundsätzlich nicht verändert werden kann. Somit entfällt für diese Spalte die Notwendigkeit, auf die Original-Version zuzugreifen.



Galileo Computing - Zum Seitenanfang

27.2.2 Beispielprogramm topZur vorigen Überschrift

Wenn Sie eine eigene Aktualisierungslogik planen, unterscheidet sich der Programmcode kaum von dem, den Sie auch unter Benutzung des CommandBuilders schreiben würden. Wir wollen im nächsten Beispiel die Methode CreateUpdateCommand testen und dabei auf die Dienste des SqlCommandBuilders nicht vollständig verzichten. Denn wie ich bereits weiter oben erwähnt habe, können die von diesem Objekt erzeugten Command-Objekte zum Löschen oder Hinzufügen einer Datenzeile durchaus verwendet werden, weil an diese Vorgänge in der Regel keine besonderen Anforderungen gestellt werden.


// ------------------------------------------------------------------
// Beispiel: ...\Kapitel 27\ManuelleAktualisierung
// ------------------------------------------------------------------
static void Main(string[] args) {
  SqlConnection con = new SqlConnection();
  con.ConnectionString = "...";
  SqlCommand cmd = new SqlCommand();
  cmd.CommandText = "SELECT ProductID, ProductName, UnitPrice,
		     UnitsInStock, Discontinued FROM Products";
  cmd.Connection = con;
  DataSet ds = new DataSet();
  SqlDataAdapter da = new SqlDataAdapter(cmd);
  SqlCommandBuilder cmb = new SqlCommandBuilder(da);
  da.UpdateCommand = CreateUpdateCommand(con);
  da.FillSchema(ds, SchemaType.Source);
  ds.Tables[0].Columns[0].AutoIncrementSeed = -1;
  ds.Tables[0].Columns[0].AutoIncrementStep = -1;
  da.Fill(ds);
  // Datenzeilen ändern
  ChangeDataRows(ds);
  // Datenzeilen hinzufügen
  AddDataRows(ds);
  // Simulation eines Konflikts
  Console.Write("Konflikt simulieren ...");
  Console.ReadLine();
  // Datenbank aktualisieren
  da.Update(ds);
  Console.WriteLine("Datenbank ist aktualisiert.");
  Console.ReadLine();
}
static void ChangeDataRows(DataSet ds){
  ds.Tables[0].Rows[0]["ProductName"] = "Pfeffer";
  ds.Tables[0].Rows[1]["Productname"] = "Salz";
  ds.Tables[0].Rows[2]["Productname"] = "Banane";
  ds.Tables[0].Rows[3]["Productname"] = "Orange";
  ds.Tables[0].Rows[4]["Productname"] = "Mango";
  ds.Tables[0].Rows[5]["UnitsInStock"] = 125;
  ds.Tables[0].Rows[6]["UnitsInStock"] = 55;
}
static void AddDataRows(DataSet ds) {
  DataRow row1 = ds.Tables[0].NewRow();
  row1["Productname"] = "Suppenhuhn";
  row1["Discontinued"] = 0;
  ds.Tables[0].Rows.Add(row1);
  DataRow row2 = ds.Tables[0].NewRow();
  row2["Productname"] = "Aachener Printe";
  row2["Discontinued"] = 0;
  ds.Tables[0].Rows.Add(row2);
}

Die Methoden ChangeDataRows und AddDataRows beschreiben die an der Tabelle Products vorgenommenen Änderungen. Es werden insgesamt sieben Datenzeilen editiert: Fünf Änderungen betreffen die Spalte ProductName, zwei die Spalte UnitsInStock. Darüber hinaus werden zwei weitere Datenzeilen zur Tabelle hinzugefügt.

In Main werden dem DataAdapter die Aktualisierungsstatements zugewiesen. Um neue Datenzeilen hinzuzufügen, ohne dafür eine eigene Methode schreiben zu müssen, wird der SqlCommandBuilder bemüht. Anschließend erfolgt der Aufruf der Methode CreateUpdateCommand, um die manuelle Aktualisierungslogik editierter Datenzeilen durchzusetzen.

Erscheint zur Laufzeit die Meldung Konflikt simulieren an der Konsole, können Sie das Konfliktverhalten testen. Öffnen Sie dazu beispielsweise den Server-Explorer und stellen Sie eine Verbindung zu der betreffenden Datenbank Northwind her. Öffnen Sie danach die Tabelle Products, und ändern Sie in einer der ersten fünf Datensätze den Lagerbestand. Setzen Sie danach die Ausführung des Beispielprogramms fort, wird am Ende die erfolgreiche Aktualisierung angezeigt.

Eine Änderung in der Spalte ProductName hingegen wird bei einem solchen Test zu einer Ausnahme vom Typ DBConcurrencyException führen, die einen Parallelitätskonflikt signalisiert. Das angestrebte Ziel wäre somit erreicht: Wir verursachen einen Konflikt, wenn zwei Anwender in der Spalte ProductName (und natürlich auch UnitPrice) derselben Datenzeile eine sich überschneidende Änderung vornehmen.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Visual C# 2010

Visual C# 2010
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Professionell entwickeln mit Visual C# 2012






 Professionell
 entwickeln mit
 Visual C# 2012


Zum Katalog: Windows Presentation Foundation






 Windows Presentation
 Foundation


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++ Handbuch






 C++ Handbuch


Zum Katalog: C/C++






 C/C++


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2010
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern