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 26 ADO.NET – Daten im lokalen Speicher
Pfeil 26.1 »DataSet«-Objekte verwenden
Pfeil 26.1.1 »DataSet«-Objekte erzeugen
Pfeil 26.1.2 Anatomie einer »DataTable«
Pfeil 26.1.3 Zugriff auf eine Tabelle im »DataSet«
Pfeil 26.1.4 Zugriff auf die Ergebnisliste
Pfeil 26.1.5 Dateninformationen in eine XML-Datei schreiben
Pfeil 26.2 Gültigkeitsprüfung im »DataSet«
Pfeil 26.2.1 Dem »DataSet« Schema-Informationen übergeben
Pfeil 26.2.2 Eigenschaften einer »DataColumn«, die zur Gültigkeitsprüfung dienen
Pfeil 26.2.3 Die »Constraints«-Klassen einer »DataTable«
Pfeil 26.2.4 Schema mit Programmcode erzeugen
Pfeil 26.2.5 Schema-Informationen mit »SqlDataAdapter« abrufen
Pfeil 26.3 Änderungen in einer DataTable vornehmen
Pfeil 26.3.1 Editieren einer DataRow
Pfeil 26.3.2 Datenzeile löschen
Pfeil 26.3.3 Neue Datenzeile hinzufügen
Pfeil 26.3.4 Der Sonderfall: Autoinkrementspalten
Pfeil 26.3.5 Was passiert bei der Änderung einer Datenzeile?
Pfeil 26.3.6 Manuelles Steuern der Eigenschaft »DataRowState«
Pfeil 26.4 Mit mehreren Tabellen arbeiten
Pfeil 26.4.1 Der Weg über JOIN-Abfragen
Pfeil 26.4.2 Mehrere Tabellen in einem »DataSet«
Pfeil 26.4.3 Eine »DataRelation« erzeugen
Pfeil 26.4.4 »DataRelation« und Einschränkungen
Pfeil 26.4.5 In Beziehung stehende Daten suchen
Pfeil 26.4.6 Ergänzung zum Speichern von Schema-Informationen in einer XML-Schema-Datei
Pfeil 26.5 Filtern und Suchen in einer DataTable
Pfeil 26.5.1 Die Methode »Find«
Pfeil 26.5.2 Die Methode »Select«
Pfeil 26.6 Objekte vom Typ »DataView«
Pfeil 26.6.1 »DataView« erzeugen
Pfeil 26.6.2 Auf die Datenzeilen in einer »DataView« zugreifen
Pfeil 26.6.3 Die Eigenschaft »Sort« und die Methode »Find«
Pfeil 26.6.4 Die Methode »FindRows«
Pfeil 26.6.5 Die Eigenschaft »RowFilter«
Pfeil 26.6.6 Die Eigenschaft »RowStateFilter«
Pfeil 26.6.7 Änderungen an einem »DataView«-Objekt
Pfeil 26.6.8 Aus einer »DataView« eine »DataTable« erzeugen


Galileo Computing - Zum Seitenanfang

26.2 Gültigkeitsprüfung im »DataSet« Zur nächsten ÜberschriftZur vorigen Überschrift


Galileo Computing - Zum Seitenanfang

26.2.1 Dem »DataSet« Schema-Informationen übergeben Zur nächsten ÜberschriftZur vorigen Überschrift

Die Daten in einer DataTable können editiert werden. Sie können auch neue Datenzeilen hinzufügen oder vorhandene löschen. Wie das gemacht wird, werden Sie noch später in diesem Kapitel sehen. Unabhängig davon, welche Änderungen Sie vorgenommen haben, betreffen diese zunächst nur das DataSet. Die Produktionsdatenbank weiß davon nichts. Erst zu einem späteren Zeitpunkt werden die Aktualisierungen mit der Update-Methode des SqlDataAdapters zur Originaldatenbank übermittelt und dort gespeichert.

Viele Spalten der Tabelle in der Datenbank unterliegen Gültigkeitsregeln: Beispielsweise lassen einige nur eine maximale Zeichenanzahl zu, andere schreiben einen eindeutigen Eintrag innerhalb der Datensätze der Tabelle vor oder lassen keinen NULL-Wert zu. Eine DataTable, die wir mit Fill füllen, ist hingegen sehr »dumm«. Sie enthält zwar alle angeforderten Daten, weiß aber nichts von den Gültigkeitsregeln, die in der Datenbank festgelegt sind. Die Folge ist, dass in der Anwendung die Daten beliebig verändert werden können, ohne dass eine Überprüfung erfolgt. Der anschließende Versuch, die Änderungen in die Datenbank zu schreiben, wird jedoch scheitern, weil die Datenbank vor der endgültigen Aktualisierung zuerst die Änderungen mit den Gültigkeitsregeln vergleicht und eine Verletzung feststellt. Es kommt zu einer Ausnahme.

Im folgenden Beispielprogramm können Sie dies ausprobieren. Hierzu dient uns wieder die schon reichlich bekannte Tabelle Products der Datenbank Northwind. Das Programm ermöglicht es, den Bezeichner des ersten Artikels (es handelt sich dabei um Chai) zu ändern. Dazu werden Sie an der Konsole aufgefordert. Die Änderung wird zuerst in das DataSet geschrieben, anschließend wird die Originaldatenbank aktualisiert. Die Aktualisierungslogik mit der Methode Update des SqlDataAdapters sowie das zuvor erzeugte Objekt vom Typ SqlCommandBuilder sollen uns an dieser Stelle nicht interessieren.


// ------------------------------------------------------------------
// Beispiel: ...\Kapitel 26\FehlgeschlageneAktualisierung
// ------------------------------------------------------------------
class Program {
  static void Main(string[] args) {
    SqlConnection con = new SqlConnection();
    con.ConnectionString = "...";
    SqlCommand cmd = new SqlCommand();
    cmd.Connection = con;
    cmd.CommandText = "SELECT ProductID, ProductName, UnitsInStock " +
                      "FROM Products";
    DataSet ds = new DataSet();
    SqlDataAdapter da = new SqlDataAdapter(cmd);
    da.Fill(ds); 
    // Ausgabe der Ergebnisliste
    Console.WriteLine("Abfrageergebnis:\n");
    foreach (DataRow row in ds.Tables[0].Rows)
      Console.WriteLine("{0,-35}{1}", row[0], row[1]);
    Console.WriteLine(new string('-',60));
    // Datenänderung
    Console.Write("Namensänderung von 'Chai': ");
    ds.Tables[0].Rows[0]["ProductName"] = Console.ReadLine();
    SqlCommandBuilder cmb = new SqlCommandBuilder(da);
    da.Update(ds);
    Console.ReadLine();
  }
}

Beachten Sie bitte, dass das Feld ProductName in der Datenbank auf eine Maximallänge von 40 Zeichen begrenzt ist. Ändern Sie den Artikelbezeichner innerhalb dieser Grenzen, wird die Datenbank die Änderung annehmen. Sollten Sie jedoch gegen die Beschränkung verstoßen, wird eine Ausnahme vom Typ SqlException ausgelöst, die von der Datenbank initiiert wird. Die geänderte Spalte im DataSet hatte keinen Einwand gegen die vorgenommene Änderung, denn bekanntlich sind die Daten im DataSet »dumm«. Der Versuch der endgültigen Aktualisierung scheitert jedoch an der Feldlängenbegrenzung in der Datenbank.

Obwohl aufgrund der Einschränkungen in der Datenbank sichergestellt ist, dass keine unzulässigen Daten geschrieben werden, stellt der gezeigte Ansatz keine gute Lösung dar. Denken Sie nur an eine stark frequentierte Datenbank im Internet. Jeder Anwender, der unzulässige Daten übermittelt, würde von der Datenbank in Form einer Ausnahme über das Scheitern der Aktualisierung informiert. Der Datenfluss von der Datenbank zum Anwender würde nicht nur das Netz belasten, sondern darüber hinaus auch die Performance der Anwendung verschlechtern.

Besser ist es, wenn bereits das DataSet die Gültigkeitsregeln kennt. Das hat zur Folge, dass Änderungen überprüft werden, bevor sie der Datenbank übermittelt werden. In unserem Beispiel hätte dann das DataSet eine Änderung des Artikelbezeichners abgelehnt, ohne dabei die Datenbank zu kontaktieren.

Um eine Gültigkeitsüberprüfung vom DataSet vornehmen zu lassen, werden Schema-Informationen benötigt, die auf drei verschiedene Weisen einer Anwendung bereitgestellt werden können:

  • Die Schema-Informationen werden mittels Programmcode für alle betreffenden Tabellen und Spalten explizit festgelegt.
  • Die Schema-Informationen werden von der Datenbank mit dem SqlDataAdapter bezogen. Dazu bieten sich die Methode FillSchema sowie die Eigenschaft MissingSchemaAction an.
  • Die Schema-Informationen werden aus einer XML-Schema-Datei bezogen.

Schema-Informationen beschreiben Datenüberprüfungsmechanismen, die sogenannten Einschränkungen (Constraints). Dabei handelt es sich um Einschränkungen auf Spalten- und Tabellenebene, die auch von einer DataTable und einer DataColumn unterstützt werden. Ehe ich Ihnen zeige, wie Sie ein DataSet davon überzeugen, eine Gültigkeitsüberprüfung vorzunehmen, sollten wir uns ansehen, wie die Beschränkungen von ADO.NET realisiert werden.


Galileo Computing - Zum Seitenanfang

26.2.2 Eigenschaften einer »DataColumn«, die zur Gültigkeitsprüfung dienen Zur nächsten ÜberschriftZur vorigen Überschrift

Um die in der Anwendung eingegebenen Daten mittels Programmcode zu überprüfen, veröffentlicht das DataColumn-Objekt, mit dem eine Spalte der Abfrage beschrieben wird, einige Eigenschaften.


Tabelle 26.1 Gültigkeitsbeschreibende Eigenschaften einer »DataColumn«

Eigenschaft Beschreibung
AllowDBNull

Mit dieser Eigenschaft legen Sie fest, ob eine Spalte den Wert NULL akzeptiert oder nicht.

MaxLength

Mit dieser Eigenschaft legen Sie die Länge einer Zeichenfolge in einer Spalte fest.

ReadOnly

Sollen die Daten einer Spalte schreibgeschützt sein, setzen Sie diese Eigenschaft für die betreffende Spalte auf true.

Unique

Mit dieser Eigenschaft geben Sie an, ob die Werte in einer Spalte eindeutig sein müssen. Ist diese Eigenschaft einer Spalte auf true gesetzt, prüft ADO.NET die Werte in jeder Zeile dieser Tabelle, wenn Sie in einer Datenzeile den Wert einer UNIQUE-Spalte ändern oder einen neuen Datensatz hinzufügen. Wird gegen die Regel verstoßen, wird die Ausnahme ConstraintException ausgelöst.



Galileo Computing - Zum Seitenanfang

26.2.3 Die »Constraints«-Klassen einer »DataTable« Zur nächsten ÜberschriftZur vorigen Überschrift

Die folgenden beiden Klassen beschreiben Einschränkungen einer DataTable:

  • UniqueConstraint
  • ForeignKeyConstraint

Beide Klassen sind von der gleichen Basisklasse Constraint abgeleitet. Da eine DataTable mehrere Einschränkungen beschreiben kann, werden alle Constraint-Objekte in einer Auflistung (Typ: ConstraintCollection) verwaltet. Die Eigenschaft Constraint der DataTable liefert die Referenz auf diese Collection.

Die Klasse »UniqueConstraint«

Ein UniqueConstraint-Objekt wird automatisch angelegt, wenn die Eigenschaft Unique einer Spalte auf true gesetzt wird. Gleichzeitig wird das Objekt der ConstraintCollection hinzugefügt. Sie können ein UniqueConstraint-Objekt natürlich auch per Code erzeugen und dessen Eigenschaft Columns der Spalte übergeben, auf der die Einschränkung gesetzt wird. Das Setzen der Eigenschaft Unique einer Spalte ist aber einfacher. Trotzdem kann das explizite Erzeugen sinnvoll sein. Das ist der Fall, wenn Sie sicherstellen müssen, dass die Kombination von Werten aus mehreren Spalten eindeutig ist.

Die Klasse »ForeignKeyConstraint«

Mit einem ForeignKeyConstraint-Objekt können Sie festlegen, wie sich eine Beziehung zwischen Tabellen bezüglich Datenänderungen auswirken soll. In der Tabelle Products der Northwind-Datenbank muss die Spalte CategoryID einen Wert enthalten, der in der Tabelle Categories enthalten ist. Der Spalte CategoryID wird dazu ein ForeignKeyConstraint-Objekt zugeordnet. Allerdings müssen Sie dieses nicht explizit erzeugen. Wenn Sie im DataSet eine Beziehung zwischen zwei Tabellen einrichten, wird automatisch ein ForeignKeyConstraint-Objekt erzeugt. Wir werden auf das Thema der Einrichtung einer Beziehung zwischen zwei Tabellen später noch einmal zurückkommen.

Primärschlüsselfelder

Primärschlüssel werden in der DataTable definiert. Die entsprechende Eigenschaft lautet PrimaryKey. Dass ein Primärschlüssel nicht die Eigenschaft einer DataColumn besitzt, liegt daran, dass viele Tabellen mehrere Spalten zu einem gemeinsamen Primärschlüssel kombinieren. Die PrimaryKey-Eigenschaft der DataTable beschreibt deshalb auch ein Array von DataColumn-Objekten. Beim Festlegen der PrimaryKey-Eigenschaft wird ein UniqueConstraint-Objekt erzeugt, um die Primärschlüsseleinschränkung durchzusetzen.


Galileo Computing - Zum Seitenanfang

26.2.4 Schema mit Programmcode erzeugen Zur nächsten ÜberschriftZur vorigen Überschrift

Die Bereitstellung eines Schemas ist verhältnismäßig aufwendig. Mit den Eigenschaften AllowDBNull, MaxLength und Unique einer DataColumn sowie PrimaryKey einer DataTable können Sie Datenmechanismen implementieren. Mit ReadOnly=true haben Sie zudem die Möglichkeit, gültige Daten vor einer Veränderung durch den Benutzer zu schützen.

Auch im folgenden Beispiel soll der Bezeichner eines Artikels der Tabelle Products geändert werden. Etwas Ähnliches habe ich ein paar Seiten zuvor schon einmal gezeigt. Diesmal wird die DataTable im DataSet jedoch mit den Schema-Informationen für die abgefragten Felder gefüllt. Aus Gründen der Übersichtlichkeit wird der entsprechende Code in eine spezielle Methode ausgelagert, die nach dem Füllen des DataSets aufgerufen wird.


// ------------------------------------------------------------------
// Beispiel: ...\Kapitel 26\SchemaPerCode
// ------------------------------------------------------------------
class Program {
  static void Main(string[] args) {
    SqlConnection con = new SqlConnection();
    con.ConnectionString = "...";
    SqlCommand cmd = new SqlCommand();
    cmd.Connection = con;
    cmd.CommandText = "SELECT ProductID, ProductName, " +
         "QuantityPerUnit, Discontinued FROM Products";
    DataSet ds = new DataSet();
    SqlDataAdapter da = new SqlDataAdapter(cmd);
    da.Fill(ds);
    FillSchemaInfos(ds.Tables[0]);
    // Der Artikelbezeichner des Artikels in der ersten Datenzeile
    // soll geändert werden.
    DataRow row = ds.Tables[0].Rows[0];
    Console.Write("Produktname ändern: ");
    row["ProductName"] = Console.ReadLine();
    // Änderung in die Originaldatenbank schreiben
    SqlCommandBuilder cmb = new SqlCommandBuilder(da);
    da.Update(ds);
    Console.WriteLine("Aktualisierung erfolgreich.");
    Console.ReadLine();
  }
  // Diese Methode füllt die Tabelle mit Schema-Informationen.
  static void FillSchemaInfos(DataTable tbl) {
    // ProductID
    tbl.PrimaryKey = new DataColumn[]{ tbl.Columns["ProductID"]};
    // ProductName
    tbl.Columns["ProductName"].MaxLength = 40;
    tbl.Columns["ProductName"].AllowDBNull = false;
    // QuantityPerUnit
    tbl.Columns["QuantityPerUnit"].MaxLength = 20;
    // Discontinued
    tbl.Columns["Discontinued"].AllowDBNull = false;
  }
}

Sie können selbst bestimmen, welchen Bezeichner der Artikel bekommen soll. Entscheiden Sie sich für einen Bezeichner mit maximal 40 Zeichen, wird die Änderung in die Datenbank geschrieben. Geben Sie aber mehr als 40 Zeichen ein, wird eine Ausnahme vom Typ ArgumentException ausgelöst. Vielleicht erinnern Sie sich an das ähnliche Aktualisierungsbeispiel weiter oben. Dort wurde das Überschreiten der zulässigen Maximallänge des Feldes ProductName mit einer Ausnahme vom Typ SqlException beantwortet. Diese kam vom SQL Server. Die Ausnahme ArgumentException hingegen wird von ADO.NET in der Clientanwendung ausgelöst.

Vergleichen Sie auch, in welcher Codezeile die Ausnahme auslöst wird: Aktualisieren Sie ohne Schema-Informationen, ist die Update-Methode des SqlDataAdapters der Urheber. Liegen Schema-Informationen im DataSet vor und wird gegen die Einschränkungen verstoßen, handelt es sich um die Anweisung mit der fehlschlagenden Zuweisung, in unserem Beispiel also:


row["ProductName"] = Console.ReadLine();

Das DataSet nimmt die Änderung überhaupt nicht entgegen. Damit ist gezeigt, dass ein DataSet mit Schema-Informationen zur Entlastung des Datenbankservers beiträgt.


Galileo Computing - Zum Seitenanfang

26.2.5 Schema-Informationen mit »SqlDataAdapter« abrufen topZur vorigen Überschrift

Schema-Informationen mit »FillSchema« abrufen

Enthält ein DataSet mehrere Tabellen mit jeweils vielen Spalten, kann die Codierung der Schema-Informationen ziemlich aufwendig sein. Ebenso können Sie mit der Methode FillSchema des SqlDataAdapters alle Schema-Informationen für das DataSet oder die DataTable abrufen. Die Methode ruft das Schema bei der Datenbank ab. Grundlage ist dabei das in SelectCommand beschriebene SELECT-Kommando. Als Ergebnis des Methodenaufrufs werden die Eigenschaften ReadOnly, AllowDBNull, AutoIncrement, Unique und MaxLength der in der Abfrage enthaltenen Spalten gesetzt. Außerdem werden die Eigenschaften PrimaryKey und Constraints der entsprechenden Tabelle festgelegt.

FillSchema ist mehrfach überladen. Alle Überladungen erwarten ein Argument vom Typ der Enumeration SchemaType. Die Aufzählung hat zwei Mitglieder: Source und Mapped. Über diese Parameter wird gesteuert, ob der SqlDataAdapter die Zuordnungen verwenden soll, die in der DataTableMappingCollection und der DataColumnMappingCollection angegeben sind.

Beschreiben Sie mittels Programmcode die Gültigkeitsregeln, können diese zu jedem beliebigen Zeitpunkt gesetzt werden. Es muss nur vor der Aktualisierung der Daten im DataSet sein. Benutzen Sie dagegen die Methode FillSchema, muss dies vor dem Füllen des DataSets erfolgen.


...
DataSet ds = new DataSet();
da.FillSchema(ds, SchemaType.Source);
da.Fill(ds);
...

Der Aufruf der Methode ist einerseits natürlich sehr bequem, aber andererseits dürfen Sie nicht vergessen, dass dabei sowohl das Netzwerk als auch die Datenbank selbst belastet werden.

Die Eigenschaft »MissingSchemaAcion« des »SqlDataAdapter«

Per Vorgabe ist der SqlDataAdapter so eingestellt, dass Spalten zu einer DataTable hinzugefügt werden, wenn diese in der DataTable noch nicht existieren. Damit stellt der SqlDataAdapter sicher, die Ergebnisse einer Abfrage speichern zu können. Gesteuert wird dieses Verhalten von der Eigenschaft MissingSchemaAction, die Werte der gleichnamigen Aufzählung beschreibt.


Tabelle 26.2 Die Werte der Enumeration »MissingSchemaAction«

Wert Beschreibung
Add

Fügt die erforderlichen Spalten zum Vervollständigen des Schemas hinzu.

AddWithKey

Findet der SqlDataAdapter eine Spalte, die noch nicht in der DataTable existiert, fügt er die Spalte hinzu und setzt die Eigenschaften MaxLength und AllowDBNull. Falls die DataTable noch nicht existiert, wird die Datenbank zudem nach Primärschlüsselinformationen abgefragt.

Error

Wenn die angegebene Spaltenzuordnung fehlt, wird die Ausnahme InvalidOperation ausgelöst.

Ignore

Ignoriert die zusätzlichen Spalten.


Legen Sie die Eigenschaft MissingSchemaAction auf den Wert AddWithKey fest, werden ähnlich wie mit der Methode FillSchema die Schema-Informationen abgerufen. Diese sind jedoch auf den Primärschlüssel der Tabelle sowie die Einschränkungen AllowDBNull und MaxLength der Spalten beschränkt. Unique, AutoIncrement und ReadOnly werden hierbei nicht berücksichtigt.

Schema-Informationen aus einer XML-Schema-Datei beziehen

Nun kennen Sie zwei Varianten, Metadaten einer Tabelle im DataSet bereitzustellen. Sie wissen, dass es sehr einfach ist, mit FillSchema oder MissingSchemaAction=AddWithKey zu arbeiten. Der Nachteil dabei ist die erhöhte Belastung des Netzes und der Datenbank. Daher ist dies wohl eher nur für Ad-hoc-Abfragen geeignet. Alternativ können Sie die Schema-Informationen auch mittels Programmcode beschreiben. Zur Laufzeit ist das sicher effektiv, weil das Netz und die Datenbank nur die tatsächlich benötigten Dateninformationen liefern müssen, während die Metadaten im Code beschrieben werden. Allerdings bedeutet das einen nicht zu vernachlässigenden Programmieraufwand.

Die nun vorgestellte dritte Möglichkeit ist wohl in den meisten Fällen diejenige, die sich am besten eignet. Ausgangspunkt sind zwei Methoden des DataSets: WriteXmlSchema und ReadXmlSchema. Mit WriteXmlSchema können Sie die Schema-Informationen eines DataSets in ein XML-Dokument schreiben und es später mit ReadXmlSchema auswerten. Das Schema enthält Definitionen von Tabellen, Beziehungen und Einschränkungen. XML-Schema-Dateien haben üblicherweise die Dateiendung .XSD.

Bevor Sie das Schema eines DataSets in einer Schema-Datei speichern, muss das Schema im DataSet bekannt sein. Sie können sich dieses daher zur Entwicklungszeit mit FillSchema besorgen und anschließend mit WriteXmlSchema in einer Datei speichern.


ds.WriteXmlSchema(@"D:\Products.xsd");

Die erzeugte Schema-Datei muss zusammen mit der Anwendung ausgeliefert werden. In Abbildung 26.2 sehen Sie die Schema-Datei, die auf einer Abfrage basiert, die die Spalten ProductID und ProductName der Tabelle Products wiedergibt.

Abbildung 26.2 Beispiel für eine mit der Methode »WriteXmlSchema« erzeugte Schema-Datei

Sie erkennen, dass die Spalte ProductID die Primärschlüsselspalte der Tabelle beschreibt. AutoIncrement=True signalisiert, das der Spaltenwert bei einer neu hinzugefügten Spalte automatisch erhöht wird. Infolgedessen gilt für die Spalte ProductID auch ReadOnly=True. Die Spalte ProductName weist lediglich eine Einschränkung auf, nämlich die Begrenzung auf maximal 40 Zeichen.

Die Auswertung einer Schema-Datei ist sehr einfach. Zur Laufzeit erzeugen Sie zuerst das DataSet-Objekt, lesen anschließend die Schema-Datei ein und füllen danach das DataSet mit den Daten.


...
DataSet ds = new DataSet();
ds.ReadXmlSchema(@"D:\Products.xsd");
da.Fill(ds);

Dateninformationen und Schema-Daten in eine Datei schreiben

Mit WriteXmlSchema erzeugen Sie eine Schema-Datei, die die Metadaten des DataSets beinhaltet. Mit der einfach parametrisierten Methode WriteXml des DataSets lassen sich die Daten in einer XML-Datei sichern.

Benötigen Sie beide Informationen, müssen Sie nicht zwangsläufig Metadaten und Dateninformationen jeweils in einer separaten Datei speichern. Mit einer Überladung von WriteXml lässt sich der aktuelle Inhalt des DataSets als XML-Daten mit den Metadaten als XSD-Inline-Schema beschreiben. Sowohl Daten als auch Schema sind in einer Datei gespeichert.


ds.WriteXml(@"D:\Products.xml", XmlWriteMode.WriteSchema);

Der Vorgabewert von XmlWriteMode ist IgnoreSchema. Das ist die Einstellung, wenn Sie die einfach parametrisierte Methode aufrufen.



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