Utilizzo di un dataset da un servizio Web XMLConsuming a DataSet from an XML Web Service

Il DataSet è stato progettato con una struttura disconnessa, in parte per facilitare il trasporto di dati su Internet.The DataSet was architected with a disconnected design, in part to facilitate the convenient transport of data over the Internet. Il set di dati è "serializzabile" in quanto può essere specificato come input o output da servizi Web XML senza scrivere codice aggiuntivo necessario per trasmettere il contenuto delle DataSet da un servizio Web XML a un client e viceversa.The DataSet is "serializable" in that it can be specified as an input to or output from XML Web services without any additional coding required to stream the contents of the DataSet from an XML Web service to a client and back. Il set di dati viene implicitamente convertito in un flusso XML utilizzando il formato DiffGram, inviati in rete e ricreato dal flusso XML come un DataSet nell'estremità ricevente.The DataSet is implicitly converted to an XML stream using the DiffGram format, sent over the network, and then reconstructed from the XML stream as a DataSet on the receiving end. Si tratta quindi di un metodo molto semplice e flessibile per la trasmissione e la restituzione di dati relazionali tramite i servizi Web XML.This gives you a very simple and flexible method for transmitting and returning relational data using XML Web services. Per altre informazioni sul formato DiffGram, vedere DiffGram.For more information about the DiffGram format, see DiffGrams.

Nell'esempio seguente viene illustrato come creare un servizio Web XML e client che usano il set di dati per il trasporto dati relazionali, inclusi i dati modificati e risolvere eventuali aggiornamenti fino all'origine dati.The following example shows how to create an XML Web service and client that use the DataSet to transport relational data (including modified data) and resolve any updates back to the original data source.

Nota

Nella creazione di un servizio Web XML si consiglia di tenere sempre presenti le implicazioni inerenti la sicurezza.We recommend that you always consider security implications when creating an XML Web service. Per informazioni sulla protezione di un servizio Web XML, vedere protezione di servizi Web XML creati utilizzando ASP.NET.For information on securing an XML Web service, see Securing XML Web Services Created Using ASP.NET.

Per creare un servizio Web XML che restituisca e utilizzi un DataSetTo create an XML Web service that returns and consumes a DataSet

  1. Creare il servizio Web XML.Create the XML Web service.

    Nell'esempio viene creato un servizio Web XML che restituisce dati, in questo caso un elenco di clienti il Northwind del database e riceve un set di dati con gli aggiornamenti ai dati, che il servizio Web XML risolve nuovamente all'origine dati originale.In the example, an XML Web service is created that returns data, in this case a list of customers from the Northwind database, and receives a DataSet with updates to the data, which the XML Web service resolves back to the original data source.

    Due metodi vengono esposti dal servizio Web XML: GetCustomersper restituire l'elenco di clienti, e UpdateCustomers, per risolvere gli aggiornamenti fino all'origine dati.The XML Web service exposes two methods: GetCustomers, to return the list of customers, and UpdateCustomers, to resolve updates back to the data source. Il servizio Web XML viene archiviato in un file sul server Web denominato DataSetSample.asmx.The XML Web service is stored in a file on the Web server called DataSetSample.asmx. Nel codice seguente viene descritto il contenuto del file DataSetSample.asmx.The following code outlines the contents of 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 uno scenario tipico, il UpdateCustomers metodo verrebbe scritto per rilevare eventuali violazioni alla concorrenza ottimistica.In a typical scenario, the UpdateCustomers method would be written to catch optimistic concurrency violations. Per semplicità, questa opzione non è stata inclusa nell'esempio.For simplicity, the example does not include this. Per altre informazioni sulla concorrenza ottimistica, vedere la concorrenza ottimistica.For more information about optimistic concurrency, see Optimistic Concurrency.

  2. Creare un proxy del servizio Web XML.Create an XML Web service proxy.

    Un proxy SOAP verrà richiesto dai client del servizio Web XML per l'uso dei metodi esposti.Clients of the XML Web service require a SOAP proxy in order to consume the exposed methods. È possibile generare questo proxy usando Visual Studio.You can have Visual Studio generate this proxy for you. Se si imposta un riferimento Web su un servizio Web esistente tramite Visual Studio, tutti i comportamenti descritti in questo passaggio si verificheranno in modo trasparente.By setting a Web reference to an existing Web service from within Visual Studio, all the behavior described in this step occurs transparently. Per creare la classe proxy autonomamente, continuare a eseguire i passaggi descritti di seguito.If you want to create the proxy class yourself, continue with this discussion. Tuttavia, nella maggior parte dei casi, per creare la classe proxy per l'applicazione client è sufficiente usare Visual Studio.In most circumstances, however, using Visual Studio to create the proxy class for the client application is sufficient.

    Per creare un proxy, è possibile usare lo Strumento del linguaggio di descrizione dei servizi Web (Wsdl.exe).A proxy can be created using the Web Services Description Language Tool. Ad esempio, se il servizio Web XML viene esposto nell'URL http://myserver/data/DataSetSample.asmx, inviare un comando simile al seguente per creare un proxy di Visual Basic .NET con uno spazio dei nomi WebData. DSSample e archiviarlo nel file Sample. vb file.For example, if the XML Web service is exposed at the URL http://myserver/data/DataSetSample.asmx, issue a command such as the following to create a Visual Basic .NET proxy with a namespace of WebData.DSSample and store it in the file sample.vb.

    wsdl /l:VB -out:sample.vb http://myserver/data/DataSetSample.asmx /n:WebData.DSSample  
    

    Per creare un proxy C# nel file sample.cs, eseguire il comando seguente.To create a C# proxy in the file sample.cs, issue the following command.

    wsdl -l:CS -out:sample.cs http://myserver/data/DataSetSample.asmx -n:WebData.DSSample  
    

    È quindi possibile compilare il proxy come libreria e importarlo nel client del servizio Web XML.The proxy can then be compiled as a library and imported into the XML Web service client. Per compilare il codice del proxy di Visual Basic .NET archiviato nel file sample.vb come sample.dll, eseguire il comando seguente.To compile the Visual Basic .NET proxy code stored in sample.vb as sample.dll, issue the following command.

    vbc -t:library -out:sample.dll sample.vb -r:System.dll -r:System.Web.Services.dll -r:System.Data.dll -r:System.Xml.dll  
    

    Per compilare il codice del proxy C# archiviato nel file sample.cs come sample.dll, eseguire il comando seguente.To compile the C# proxy code stored in sample.cs as sample.dll, issue the following command.

    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. Creare un client del servizio Web XML.Create an XML Web service client.

    Se si vuole generare la classe proxy del servizio Web per l'utente con Visual Studio, è sufficiente creare il progetto client e, nella finestra Esplora soluzioni fare clic sul progetto, fare clic su Aggiungi riferimento Web, quindi selezionare il servizio Web da l'elenco dei servizi Web disponibili (potrebbe essere necessario fornire l'indirizzo dell'endpoint del servizio Web, se il servizio Web non è disponibile nella soluzione corrente o nel computer corrente.) Se si crea autonomamente il proxy del servizio Web XML, come descritto nel passaggio precedente, è possibile importarlo nel codice del client e usare i metodi del servizio Web XML.If you want to have Visual Studio generate the Web service proxy class for you, simply create the client project, and, in the Solution Explorer window, right-click the project, click Add Web Reference, and select the Web service from the list of available Web services (this may require supplying the address of the Web service endpoint, if the Web service isn't available within the current solution, or on the current computer.) If you create the XML Web service proxy yourself (as described in the previous step), you can import it into your client code and consume the XML Web service methods. Esempio di codice seguente importa la libreria del proxy, le chiamate GetCustomers per ottenere un elenco di clienti, aggiunge un nuovo cliente e quindi restituisce un DataSet con gli aggiornamenti di UpdateCustomers .The following sample code imports the proxy library, calls GetCustomers to get a list of customers, adds a new customer, and then returns a DataSet with the updates to UpdateCustomers.

    Si noti che nell'esempio vengono passate le set di dati restituito da GetChanges al UpdateCustomers perché solo le righe modificate devono essere passati a UpdateCustomers.Notice that the example passes the DataSet returned by DataSet.GetChanges to UpdateCustomers because only modified rows need to be passed to UpdateCustomers. UpdateCustomers restituisce l'oggetto risolto set di dati, che è quindi possibile Merge esistente set di dati per incorporare le modifiche risolte ed eventuali informazioni sugli errori di riga rispetto all'aggiornamento.UpdateCustomers returns the resolved DataSet, which you can then Merge into the existing DataSet to incorporate the resolved changes and any row error information from the update. Il codice seguente si presuppone che è stato usato Visual Studio per creare il riferimento Web, e che sia stato rinominato il riferimento Web come DsSample nella finestra di Aggiungi riferimento Web nella finestra di dialogo.The following code assumes that you have used Visual Studio to create the Web reference, and that you have renamed the Web reference to DsSample in the Add Web Reference dialog box.

    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();  
      }  
    }  
    

    Se si crea la classe proxy autonomamente, invece, è necessario eseguire i seguenti passaggi aggiuntivi.If you decide to create the proxy class yourself, you must take the following extra steps. Per compilare l'esempio, fornire la libreria del proxy creata (sample.dll) e le librerie .NET correlate.To compile the sample, supply the proxy library that was created (sample.dll) and the related .NET libraries. Per compilare la versione di Visual Basic .NET dell'esempio, archiviata nel file client.vb, eseguire il comando seguente.To compile the Visual Basic .NET version of the sample, stored in the file client.vb, issue the following command.

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

    Per compilare la versione C# dell'esempio, archiviata nel file client.cs, eseguire il comando seguente.To compile the C# version of the sample, stored in the file client.cs, issue the following command.

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

Vedere ancheSee also