Delen via


Een Gegevensset gebruiken vanuit een XML-webservice

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

  1. 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.

  2. 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  
    
  3. 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  
    

Zie ook