Kommentieren von typierten DataSets

Anmerkungen ermöglichen es Ihnen, die Namen der Elemente Ihrer Eingaben DataSet zu modifizieren, ohne das zugrundeliegende Schema zu verändern. Das Ändern der Namen der Elemente in Ihrem zugrunde liegenden Schema würde dazu führen, dass die eingegebenen DataSet Elemente auf Objekte verweisen, die nicht in der Datenquelle vorhanden sind, sowie einen Verweis auf die Objekte verlieren, die in der Datenquelle vorhanden sind.

Mithilfe von Anmerkungen können Sie die Namen von Objekten in Ihrer Eingabe DataSet mit aussagekräftigeren Namen anpassen, wodurch Code besser lesbar ist und die Eingabe DataSet für Clients einfacher zu verwenden ist, während das zugrunde liegende Schema intakt bleibt. Beispielsweise würde das folgende Schemaelement für die Customers-Tabelle der Northwind-Datenbank zu einem Objekt mit dem Namen DataRowCustomersRow und einem DataRowCollection namens Customers führen.

<xs:element name="Customers">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="CustomerID" type="xs:string" minOccurs="0" />
    </xs:sequence>
  </xs:complexType>
</xs:element>

Ein DataRowCollection Name von Customers ist im Clientcode aussagekräftig, aber ein DataRow Name von CustomersRow ist irreführend, da es sich um ein einzelnes Objekt handelt. In gängigen Szenarien würde das Objekt auch ohne den Row Bezeichner bezeichnet und stattdessen einfach als Customer Objekt bezeichnet. Die Lösung besteht darin, das Schema zu annotieren und neue Namen für die Objekte DataRow und DataRowCollection zu identifizieren. Es folgt die kommentierte Version des vorherigen Schemas.

<xs:element name="Customers" codegen:typedName="Customer" codegen:typedPlural="Customers">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="CustomerID" type="xs:string" minOccurs="0" />
    </xs:sequence>
  </xs:complexType>
</xs:element>

Die Angabe eines typedName Werts Customer führt zu einem DataRow Objektnamen des Kunden. Ein typedPlural-Wert von Customers bewahrt den DataRowCollection-Namen von Kunden.

In der folgenden Tabelle sind die anmerkungen aufgeführt, die zur Verwendung zur Verfügung stehen.

In der folgenden Tabelle sind die Werte aufgeführt, die für die nullValue Anmerkung angegeben werden können.

In der folgenden Tabelle sind Standardwerte für Objekte in einer typierten DataSet und die verfügbaren Anmerkungen aufgeführt.

Wenn Sie typisierte DataSet Anmerkungen verwenden möchten, müssen Sie den folgenden xmlns Verweis in das XSD-Schema (XML Schema Definition Language) einbeziehen. Informationen zum Erstellen eines XSD aus Datenbanktabellen finden Sie unter WriteXmlSchema oder Arbeiten mit Datasets in Visual Studio.

xmlns:codegen="urn:schemas-microsoft-com:xml-msprop"

Im Folgenden finden Sie ein Beispiel für ein kommentiertes Schema, das die Customers Tabelle der Northwind Datenbank mit einer Beziehung zur Orders enthaltenen Tabelle verfügbar macht.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="CustomerDataSet"
      xmlns:codegen="urn:schemas-microsoft-com:xml-msprop"
      xmlns=""
      xmlns:xs="http://www.w3.org/2001/XMLSchema"
      xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
  <xs:element name="CustomerDataSet" msdata:IsDataSet="true">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Customers" codegen:typedName="Customer" codegen:typedPlural="Customers">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="CustomerID"
codegen:typedName="CustomerID" type="xs:string" minOccurs="0" />
              <xs:element name="CompanyName"
codegen:typedName="CompanyName" type="xs:string" minOccurs="0" />
              <xs:element name="Phone" codegen:typedName="Phone" codegen:nullValue="" type="xs:string" minOccurs="0" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="Orders" codegen:typedName="Order" codegen:typedPlural="Orders">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="OrderID" codegen:typedName="OrderID"
type="xs:int" minOccurs="0" />
              <xs:element name="CustomerID"
codegen:typedName="CustomerID"                  codegen:nullValue="" type="xs:string" minOccurs="0" />
              <xs:element name="EmployeeID"
codegen:typedName="EmployeeID" codegen:nullValue="0"
type="xs:int" minOccurs="0" />
              <xs:element name="OrderAdapter"
codegen:typedName="OrderAdapter" codegen:nullValue="1980-01-01T00:00:00"
type="xs:dateTime" minOccurs="0" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:choice>
    </xs:complexType>
    <xs:unique name="Constraint1">
      <xs:selector xpath=".//Customers" />
      <xs:field xpath="CustomerID" />
    </xs:unique>
    <xs:keyref name="CustOrders" refer="Constraint1"
codegen:typedParent="Customer" codegen:typedChildren="GetOrders">
      <xs:selector xpath=".//Orders" />
      <xs:field xpath="CustomerID" />
    </xs:keyref>
  </xs:element>
</xs:schema>

Im folgenden Codebeispiel wird ein stark typierter DataSet Code verwendet, der aus dem Beispielschema erstellt wurde. Sie verwendet eine SqlDataAdapter, um die Customers Tabelle zu füllen, und eine andere SqlDataAdapter, um die Orders Tabelle zu füllen. Der stark typisierte DataSet definiert die DataRelations.

' Assumes a valid SqlConnection object named connection.
Dim customerAdapter As SqlDataAdapter = New SqlDataAdapter( _
    "SELECT CustomerID, CompanyName, Phone FROM Customers", &
    connection)
Dim orderAdapter As SqlDataAdapter = New SqlDataAdapter( _
    "SELECT OrderID, CustomerID, EmployeeID, OrderAdapter FROM Orders", &
    connection)

' Populate a strongly typed DataSet.
connection.Open()
Dim customers As CustomerDataSet = New CustomerDataSet()
customerAdapter.Fill(customers, "Customers")
orderAdapter.Fill(customers, "Orders")
connection.Close()

' Add a strongly typed event.
AddHandler customers.Customers.CustomerChanged, &
    New CustomerDataSet.CustomerChangeEventHandler( _
    AddressOf OnCustomerChanged)

' Add a strongly typed DataRow.
Dim newCustomer As CustomerDataSet.Customer = _
    customers.Customers.NewCustomer()
newCustomer.CustomerID = "NEW01"
newCustomer.CompanyName = "My New Company"
customers.Customers.AddCustomer(newCustomer)

' Navigate the child relation.
Dim customer As CustomerDataSet.Customer
Dim order As CustomerDataSet.Order

For Each customer In customers.Customers
  Console.WriteLine(customer.CustomerID)
  For Each order In customer.GetOrders()
    Console.WriteLine(vbTab & order.OrderID)
  Next
Next

Private Shared Sub OnCustomerChanged( _
    sender As Object, e As CustomerDataSet.CustomerChangeEvent)

End Sub

// Assumes a valid SqlConnection object named connection.
SqlDataAdapter customerAdapter = new SqlDataAdapter(
    "SELECT CustomerID, CompanyName, Phone FROM Customers",
    connection);
SqlDataAdapter orderAdapter = new SqlDataAdapter(
    "SELECT OrderID, CustomerID, EmployeeID, OrderAdapter FROM Orders",
    connection);

// Populate a strongly typed DataSet.
connection.Open();
CustomerDataSet customers = new CustomerDataSet();
customerAdapter.Fill(customers, "Customers");
orderAdapter.Fill(customers, "Orders");
connection.Close();

// Add a strongly typed event.
customers.Customers.CustomerChanged += new
  CustomerDataSet.CustomerChangeEventHandler(OnCustomerChanged);

// Add a strongly typed DataRow.
CustomerDataSet.Customer newCustomer =
    customers.Customers.NewCustomer();
newCustomer.CustomerID = "NEW01";
newCustomer.CompanyName = "My New Company";
customers.Customers.AddCustomer(newCustomer);

// Navigate the child relation.
foreach(CustomerDataSet.Customer customer in customers.Customers)
{
  Console.WriteLine(customer.CustomerID);
  foreach(CustomerDataSet.Order order in customer.GetOrders())
    Console.WriteLine("\t" + order.OrderID);
}

protected static void OnCustomerChanged(object sender, CustomerDataSet.CustomerChangeEvent e)
    {

    }

Siehe auch

• DataColumnCollection
• DataSet
• Typisierte DataSets
• "DataSets", "DataTables" und "DataViews"
• Übersicht über ADO.NET