Verwenden eines DataSets aus einem XML-Webdienst

Artikel
03/31/2008

Das DataSet wurde mit einer nicht verbundenen Struktur erstellt. Auf diese Art und Weise wird z. B. eine komfortable Übertragung von Daten über das Internet ermöglicht. DataSet und DataTable sind in sofern "serialisierbar", als sie als Eingabe in oder Ausgabe aus XML-Webdiensten angegeben werden können, ohne dass eine zusätzliche Codierung erforderlich ist, um den Inhalt des DataSets von einem XML-Webdienst zu einem Client und zurück zu übertragen. Das DataSet wird implizit mit dem DiffGram-Format in einen XML-Stream konvertiert, über das Netzwerk gesendet und dann beim Empfänger aus dem XML-Stream als DataSet wiederhergestellt. Dadurch steht Ihnen eine sehr einfache und flexible Methode zum Übertragen und Zurückübertragen von relationalen Daten mit Hilfe von XML-Webdiensten zur Verfügung. Weitere Informationen zum DiffGram-Format finden Sie unter DiffGrams.

Das folgende Beispiel zeigt die Schritte zum Erstellen eines XML-Webdienstes sowie einen Client für diesen Dienst, der das DataSet zur Übertragung relationaler Daten (einschließlich Änderungen an diesen Daten) verwendet und entsprechende Aktualisierungen an die ursprüngliche Datenquelle zurücküberträgt.

Hinweis Beim Erstellen eines XML-Webdienstes sollten immer die Auswirkungen von Sicherheitsrichtlinien berücksichtigt werden. Informationen über das Sichern eines XML-Webdienstes finden Sie unter Sichern von mit ASP.NET erstellten XML-Webdiensten.

So erstellen Sie einen XML-Webdienst, der ein DataSet zurückgibt und verarbeitet

Erstellen Sie den XML-Webdienst.

Im Beispiel wird ein XML-Webdienst erstellt, der Daten zurückgibt – in diesem Fall eine Liste mit Kunden aus der Northwind-Datenbank – und ein DataSet mit Aktualisierungen zu den Daten empfängt, die der XML-Webdienst an die ursprüngliche Datenquelle zurücksendet.

Der XML-Webdienst stellt zwei Methoden zur Verfügung: GetCustomers, um die Liste der Kunden zurückzugeben, und UpdateCustomers, um Aktualisierungen an die Datenquelle zurückzusenden. Der XML-Webdienst wird in einer Datei auf dem Webserver mit dem Namen DataSetSample.asmx gespeichert. Der folgende Code zeigt den Inhalt von DataSetSample.asmx.

<% @ WebService Language = "VB" Class = "Sample" %>
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports System.Web.Services

<WebService(Namespace:="https://microsoft.com/webservices/")> _
Public Class Sample

  Public nwindConn As SqlConnection = New SqlConnection("Data Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind")

  <WebMethod( Description := "Returns Northwind Customers", EnableSession := False )> _
  Public Function GetCustomers() As DataSet
    Dim custDA As SqlDataAdapter = New SqlDataAdapter("SELECT CustomerID, CompanyName FROM Customers", nwindConn)

    Dim custDS As DataSet = New DataSet()
    custDA.MissingSchemaAction = MissingSchemaAction.AddWithKey
    custDA.Fill(custDS, "Customers")

    GetCustomers = custDS
  End Function

  <WebMethod( Description := "Updates Northwind Customers", EnableSession := False )> _
  Public Function UpdateCustomers(custDS As DataSet) As DataSet
    Dim custDA As SqlDataAdapter = New SqlDataAdapter()

    custDA.InsertCommand = New SqlCommand("INSERT INTO Customers (CustomerID, CompanyName) " & _
                                          "Values(@CustomerID, @CompanyName)", nwindConn)
    custDA.InsertCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID")
    custDA.InsertCommand.Parameters.Add("@CompanyName", SqlDbType.NChar, 15, "CompanyName")

    custDA.UpdateCommand = New SqlCommand("UPDATE Customers Set CustomerID = @CustomerID, " & _
                                          "CompanyName = @CompanyName WHERE CustomerID = @OldCustomerID", nwindConn)
    custDA.UpdateCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID")
    custDA.UpdateCommand.Parameters.Add("@CompanyName", SqlDbType.NChar, 15, "CompanyName")

    Dim myParm As SqlParameter = custDA.UpdateCommand.Parameters.Add("@OldCustomerID", SqlDbType.NChar, 5, "CustomerID")
    myParm.SourceVersion = DataRowVersion.Original

    custDA.DeleteCommand = New SqlCommand("DELETE FROM Customers WHERE CustomerID = @CustomerID", nwindConn)
    myParm = custDA.DeleteCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID")
    myParm.SourceVersion = DataRowVersion.Original

    custDA.Update(custDS, "Customers")

    UpdateCustomers = custDS
  End Function
End Class
[C#]
<% @ WebService Language = "C#" Class = "Sample" %>
using System;
using System.Data;
using System.Data.SqlClient;
using System.Web.Services;

[WebService(Namespace="https://microsoft.com/webservices/")]
public class Sample
{
  public SqlConnection nwindConn = new SqlConnection("Data Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind");

  [WebMethod( Description = "Returns Northwind Customers", EnableSession = false )]
  public DataSet GetCustomers()
  {
    SqlDataAdapter custDA = new SqlDataAdapter("SELECT CustomerID, CompanyName FROM Customers", nwindConn);

    DataSet custDS = new DataSet();
    custDA.MissingSchemaAction = MissingSchemaAction.AddWithKey;
    custDA.Fill(custDS, "Customers");

    return custDS;
  }

  [WebMethod( Description = "Updates Northwind Customers", EnableSession = false )]
  public DataSet UpdateCustomers(DataSet custDS)
  {
    SqlDataAdapter custDA = new SqlDataAdapter();

    custDA.InsertCommand = new SqlCommand("INSERT INTO Customers (CustomerID, CompanyName) " +
                                          "Values(@CustomerID, @CompanyName)", nwindConn);
    custDA.InsertCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID");
    custDA.InsertCommand.Parameters.Add("@CompanyName", SqlDbType.NChar, 15, "CompanyName");

    custDA.UpdateCommand = new SqlCommand("UPDATE Customers Set CustomerID = @CustomerID, " +
                                          "CompanyName = @CompanyName WHERE CustomerID = @OldCustomerID", nwindConn);
    custDA.UpdateCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID");
    custDA.UpdateCommand.Parameters.Add("@CompanyName", SqlDbType.NChar, 15, "CompanyName");
    SqlParameter myParm = custDA.UpdateCommand.Parameters.Add("@OldCustomerID", SqlDbType.NChar, 5, "CustomerID");
    myParm.SourceVersion = DataRowVersion.Original;

    custDA.DeleteCommand = new SqlCommand("DELETE FROM Customers WHERE CustomerID = @CustomerID", nwindConn);
    myParm = custDA.DeleteCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID");
    myParm.SourceVersion = DataRowVersion.Original;

    custDA.Update(custDS, "Customers");

    return custDS;
  }
}

In einem typischen Szenario würde die UpdateCustomers-Methode geschrieben, um Verletzungen der vollständigen Parallelität abzufangen. Der Einfachheit halber wurde im Beispiel darauf verzichtet. Weitere Informationen über die vollständige Parallelität finden Sie unter Vollständige Parallelität.

Erstellen Sie einen XML-Webdienstproxy.

Clients des XML-Webdienstes benötigen einen SOAP-Proxy, um die zur Verfügung gestellten Methoden verarbeiten zu können. Ein Proxy kann mit dem Web Services Description Language-Tool (Wsdl.exe) erstellt werden. Wenn der XML-Webdienst z. B. am URL http://myserver/data/DataSetSample.asmx zur Verfügung gestellt wird, verwenden Sie einen Befehl ähnlich dem folgenden, um einen Visual Basic .NET-Proxy mit dem Namespace WebData.DSSample zu erstellen und in der Datei sample.vb zu speichern:
```
wsdl /l:VB /out:sample.vb http://myserver/data/DataSetSample.asmx /n:WebData.DSSample
```
Zum Erstellen eines C#-Proxys in der Datei sample.cs verwenden Sie den folgenden Befehl:
```
wsdl /:CS /out:sample.cs http://myserver/data/DataSetSample.asmx /n:WebData.DSSample
```
Der Proxy kann dann als Bibliothek kompiliert und in einen XML-Webdienstclient importiert werden. Zum Kompilieren des Visual Basic .NET-Proxycodes, der in der Datei sample.vb als sample.dll gespeichert wird, verwenden Sie den folgenden Befehl:
```
vbc /t:library /out:sample.dll sample.vb /r:System.dll /r:System.Web.Services.dll /r:System.Data.dll /r:System.Xml.dll
```
Zum Kompilieren des C#-Proxycodes, der in der Datei sample.cs als sample.dll gespeichert ist, verwenden Sie den folgenden Befehl:
```
csc /t:library /out:sample.dll sample.cs /r:System.dll /r:System.Web.Services.dll /r:System.Data.dll /r:System.Xml.dll
```

Erstellen Sie einen XML-Webdienstclient.

Nachdem Sie den XML-Webdienstproxy erstellt haben, können Sie diesen in Ihren Clientcode einfügen und die XML-Webdienstmethoden verarbeiten. Der folgende Beispielcode importiert die Proxybibliothek, ruft GetCustomers auf, um eine Liste der Kunden abzurufen, fügt einen neuen Kunden hinzu und gibt dann ein DataSet mit den Aktualisierungen an UpdateCustomers zurück. Beachten Sie, dass das Beispiel das von DataSet.GetChanges zurückgegebene DataSet an UpdateCustomers übergibt, weil nur geänderte Zeilen an UpdateCustomers übergeben werden müssen. UpdateCustomers gibt das aufgelöste DataSet zurück, das Sie anschließend über Merge mit dem vorhandenen DataSet zusammenführen können, um die aufgelösten Änderungen und die Zeilenfehlerinformationen aus der Aktualisierung zu integrieren.

Imports System
Imports System.Data
Imports WebData.DSSample

Public Class Client

  Public Shared Sub Main()
    Dim mySamp As Sample = New Sample()  ' Proxy object.

    Dim myDS As DataSet = mySamp.GetCustomers()

    Dim myTable As DataTable = myDS.Tables("Customers")

    Dim newRow As DataRow = myTable.NewRow()
    newRow("CustomerID") = "ABCDE"
    newRow("CompanyName") = "New Company Name"
    myTable.Rows.Add(newRow)

    Dim updDS As DataSet = mySamp.UpdateCustomers(myDS.GetChanges())

    myDS.Merge(updDS)
    myDS.AcceptChanges()
  End Sub
End Class
[C#]
using System;
using System.Data;
using WebData.DSSample;

public class Client
{
  public static void Main()
  {
    Sample mySamp = new Sample();  // Proxy object.

    DataSet myDS = mySamp.GetCustomers();

    DataTable myTable = myDS.Tables["Customers"];

    DataRow newRow = myTable.NewRow();
    newRow["CustomerID"] = "ABCDE";
    newRow["CompanyName"] = "New Company Name";
    myTable.Rows.Add(newRow);

    DataSet updDS = new DataSet();

    updDS = mySamp.UpdateCustomers(myDS.GetChanges());

    myDS.Merge(updDS);
    myDS.AcceptChanges();
  }
}

Zum Kompilieren des Beispiels müssen Sie die erstellte Proxybibliothek (sample.dll) und die zugehörigen .NET-Bibliotheken bereitstellen. Zum Kompilieren der Visual Basic .NET-Version des Beispiels, das in der Datei client.vb gespeichert ist, verwenden Sie den folgenden Befehl:

vbc client.vb /r:sample.dll /r:System.dll /r:System.Data.dll /r:System.Xml.dll /r:System.Web.Services.dll

Zum Kompilieren der C#-Version des Beispiels, das in der Datei client.cs gespeichert ist, verwenden Sie den folgenden Befehl:

csc client.cs /r:sample.dll /r:System.dll /r:System.Data.dll /r:System.Xml.dll /r:System.Web.Services.dll

Siehe auch

Beispielszenarien zu ADO.NET | Zugreifen auf Daten mit ADO.NET | Datenzugriff mit .NET Framework-Datenprovidern | Erstellen und Verwenden von DataSets | Erstellen und Verwenden von Datentabellen | Auffüllen eines DataSets mit einem DataAdapter-Objekt | Aktualisieren der Datenbank mit einem DataAdapter und dem DataSet | Verwenden von Parametern mit einem DataAdapter

Freigeben über

Verwenden eines DataSets aus einem XML-Webdienst

Siehe auch

Zusätzliche Ressourcen