Een Gegevensset gebruiken vanuit een XML-webservice

Artikel
03/05/2024

Het DataSet ontwerp is ontworpen met een niet-verbonden ontwerp, deels om het handige transport van gegevens via internet te vergemakkelijken. De DataSet is 'serialiseerbaar' omdat deze kan worden opgegeven als invoer voor of uitvoer van XML-webservices zonder dat extra codering vereist is om de inhoud van de DataSet van een XML-webservice naar een client en terug te streamen. De DataSet wordt impliciet geconverteerd naar een XML-stroom met behulp van de DiffGram-indeling, verzonden via het netwerk en vervolgens gereconstrueerd vanuit de XML-stroom als een DataSet aan het ontvangende einde. Dit biedt u een eenvoudige en flexibele methode voor het verzenden en retourneren van relationele gegevens met behulp van XML-webservices. Zie DiffGrams voor meer informatie over de DiffGram-indeling.

In het volgende voorbeeld ziet u hoe u een XML-webservice en -client maakt die de DataSet gebruikt om relationele gegevens (inclusief gewijzigde gegevens) te transporteren en eventuele updates terug te zetten naar de oorspronkelijke gegevensbron.

Notitie

DataSet Verzenden of DataTable exemplaren als onderdeel van XML-webservice-aanroepen zijn niet veilig als de invoer niet wordt vertrouwd. Zie de beveiligingsrichtlijnen voor DataSet en DataTable voor meer informatie. U wordt ook aangeraden altijd rekening te houden met de gevolgen voor de beveiliging bij het maken van een XML-webservice. Zie Xml-webservices beveiligen die zijn gemaakt met ASP.NET voor meer informatie over het beveiligen van een XML-webservice.

Een XML-webservice maken

Maak de XML-webservice.

In het voorbeeld wordt een XML-webservice gemaakt die gegevens retourneert, in dit geval een lijst met klanten uit de Northwind-database en een DataSet ontvangt met updates voor de gegevens, die de XML-webservice terugzet naar de oorspronkelijke gegevensbron.

De XML-webservice biedt twee methoden: GetCustomers, om de lijst met klanten en UpdateCustomers te retourneren om updates terug te sturen naar de gegevensbron. De XML-webservice wordt opgeslagen in een bestand op de webserver met de naam DataSetSample.asmx. De volgende code bevat een overzicht van de inhoud van DataSetSample.asmx.

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

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

Public connection As SqlConnection = New SqlConnection("Data Source=(local);Integrated Security=SSPI;Initial Catalog=Northwind")  

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

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

    Return custDS  
  End Function  

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

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

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

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

    adapter.DeleteCommand = New SqlCommand( _  
      "DELETE FROM Customers WHERE CustomerID = @CustomerID", _  
      connection)  
    parameter = adapter.DeleteCommand.Parameters.Add( _  
      "@CustomerID", SqlDbType.NChar, 5, "CustomerID")  
    parameter.SourceVersion = DataRowVersion.Original  

    adapter.Update(custDS, "Customers")  

    Return custDS  
  End Function  
End Class

<% @ WebService Language = "C#" Class = "Sample" %>  
using System;  
using System.Data;  
using System.Data.SqlClient;  
using System.Web.Services;  

[WebService(Namespace="http://microsoft.com/webservices/")]  
public class Sample  
{  
  public SqlConnection connection = new SqlConnection("Data Source=(local);Integrated Security=SSPI;Initial Catalog=Northwind");  

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

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

    return custDS;  
  }  

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

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

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

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

    adapter.Update(custDS, "Customers");  

    return custDS;  
  }  
}

In een typisch scenario wordt de methode UpdateCustomers geschreven om optimistische gelijktijdigheidsschendingen te ondervangen. Ter vereenvoudiging bevat het voorbeeld dit niet. Zie Optimistische gelijktijdigheid voor meer informatie over optimistische gelijktijdigheid.

Maak een XML-webserviceproxy.

Clients van de XML-webservice vereisen een SOAP-proxy om de weergegeven methoden te kunnen gebruiken. Visual Studio kan deze proxy voor u genereren. Door een webverwijzing in te stellen op een bestaande webservice vanuit Visual Studio, treedt al het gedrag dat in deze stap wordt beschreven, transparant op. Als u de proxyklasse zelf wilt maken, gaat u verder met deze discussie. In de meeste gevallen is het echter voldoende om visual Studio te gebruiken om de proxyklasse voor de clienttoepassing te maken.

Er kan een proxy worden gemaakt met behulp van het taalprogramma voor beschrijvingen van webservices. Als de XML-webservice bijvoorbeeld wordt weergegeven op de URL http://myserver/data/DataSetSample.asmx, geeft u een opdracht uit zoals het volgende om een Visual Basic .NET-proxy te maken met een naamruimte van WebData.DSSample en op te slaan in het bestand sample.vb.
```
wsdl /l:VB -out:sample.vb http://myserver/data/DataSetSample.asmx /n:WebData.DSSample  
```
Voer de volgende opdracht uit om een C#-proxy te maken in het bestand sample.cs.
```
wsdl -l:CS -out:sample.cs http://myserver/data/DataSetSample.asmx -n:WebData.DSSample  
```
De proxy kan vervolgens worden gecompileerd als een bibliotheek en worden geïmporteerd in de XML-webserviceclient. Als u de Visual Basic .NET-proxycode wilt compileren die is opgeslagen in sample.vb als sample.dll, voert u de volgende opdracht uit.
```
vbc -t:library -out:sample.dll sample.vb -r:System.dll -r:System.Web.Services.dll -r:System.Data.dll -r:System.Xml.dll  
```
Voer de volgende opdracht uit om de C#-proxycode te compileren die is opgeslagen in sample.cs als sample.dll.
```
csc -t:library -out:sample.dll sample.cs -r:System.dll -r:System.Web.Services.dll -r:System.Data.dll -r:System.Xml.dll  
```
Maak een XML-webserviceclient.

Als u visual Studio de proxyklasse van de webservice voor u wilt laten genereren, maakt u gewoon het clientproject en klikt u in het Solution Explorer-venster met de rechtermuisknop op het project en selecteert u Vervolgens Serviceverwijzing toevoegen>. Selecteer Geavanceerd in het dialoogvenster Servicereferentie toevoegen en selecteer vervolgens Webreferentie toevoegen. Selecteer de webservice in de lijst met beschikbare webservices (mogelijk moet u hiervoor het adres van het webservice-eindpunt opgeven als de webservice niet beschikbaar is binnen de huidige oplossing of op de huidige computer). Als u de XML-webserviceproxy zelf maakt (zoals beschreven in de vorige stap), kunt u deze importeren in uw clientcode en de XML-webservicemethoden gebruiken.

De volgende voorbeeldcode importeert de proxybibliotheek, roept GetCustomers aan om een lijst met klanten op te halen, voegt een nieuwe klant toe en retourneert vervolgens een DataSet met de updates voor UpdateCustomers.

In het voorbeeld wordt de DataSet doorgegeven die door DataSet.GetChanges wordt geretourneerd aan UpdateCustomers , omdat alleen gewijzigde rijen moeten worden doorgegeven aan UpdateCustomers. UpdateCustomers retourneert de opgeloste DataSet, die u vervolgens kunt samenvoegen in de bestaande DataSet om de opgeloste wijzigingen en informatie over rijfouten uit de update op te nemen. In de volgende code wordt ervan uitgegaan dat u Visual Studio hebt gebruikt om de webverwijzing te maken en dat u de naam van de webverwijzing hebt gewijzigd in DsSample in het dialoogvenster Webverwijzing toevoegen.
```
Imports System  
Imports System.Data  

Public Class Client  

  Public Shared Sub Main()  
    Dim proxySample As New DsSample.Sample ()  ' Proxy object.  
    Dim customersDataSet As DataSet = proxySample.GetCustomers()  
    Dim customersTable As DataTable = _  
      customersDataSet.Tables("Customers")  

    Dim rowAs DataRow = customersTable.NewRow()  
    row("CustomerID") = "ABCDE"  
    row("CompanyName") = "New Company Name"  
    customersTable.Rows.Add(row)  

    Dim updateDataSet As DataSet = _  
      proxySample.UpdateCustomers(customersDataSet.GetChanges())  

    customersDataSet.Merge(updateDataSet)  
    customersDataSet.AcceptChanges()  
  End Sub  
End Class  
```
```
using System;  
using System.Data;  

public class Client  
{  
  public static void Main()  
  {  
    Sample proxySample = new DsSample.Sample();  // Proxy object.  
    DataSet customersDataSet = proxySample.GetCustomers();  
    DataTable customersTable = customersDataSet.Tables["Customers"];  

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

    DataSet updateDataSet = new DataSet();  

    updateDataSet =
      proxySample.UpdateCustomers(customersDataSet.GetChanges());  

    customersDataSet.Merge(updateDataSet);  
    customersDataSet.AcceptChanges();  
  }  
}  
```
Als u zelf besluit de proxyklasse te maken, moet u de volgende extra stappen uitvoeren. Als u het voorbeeld wilt compileren, geeft u de proxybibliotheek op die is gemaakt (sample.dll) en de bijbehorende .NET-bibliotheken. Als u de .NET-versie van Visual Basic van het voorbeeld wilt compileren, opgeslagen in het bestand client.vb, voert u de volgende opdracht uit.
```
vbc client.vb -r:sample.dll -r:System.dll -r:System.Data.dll -r:System.Xml.dll -r:System.Web.Services.dll  
```
Voer de volgende opdracht uit om de C#-versie van het voorbeeld te compileren, opgeslagen in het bestand client.cs.
```
csc client.cs -r:sample.dll -r:System.dll -r:System.Data.dll -r:System.Xml.dll -r:System.Web.Services.dll  
```

Delen via

Een Gegevensset gebruiken vanuit een XML-webservice

Een XML-webservice maken

Zie ook

Aanvullende resources