Consommer un DataSet à partir d’un service web XML

2025-06-20

L'objet DataSet a été conçu avec une architecture déconnectée, en partie afin de faciliter le transport des données sur Internet. Le DataSet est « sérialisable » dans lequel il peut être spécifié en tant qu’entrée ou sortie à partir de services Web XML sans code supplémentaire requis pour diffuser en continu le contenu du DataSet à partir d’un service web XML vers un client et de retour. Le DataSet est implicitement converti en flux XML à l’aide du format DiffGram, envoyé sur le réseau, puis reconstruit à partir du flux XML en tant que DataSet à la fin de la réception. Cela vous offre une méthode simple et flexible pour transmettre et retourner des données relationnelles à l’aide de services Web XML. Pour plus d’informations sur le format DiffGram, consultez DiffGrams.

L’exemple suivant montre comment créer un service web XML et un client qui utilisent DataSet pour transporter les données relationnelles (y compris les données modifiées) et résoudre les mises à jour apportées à la source de données d’origine.

Remarque

Transmettre des instances de DataSet ou DataTable dans le cadre d'appels de services Web XML n'est pas sûr si l'entrée n'est pas approuvée. Pour plus d’informations, consultez les conseils de sécurité DataSet et DataTable. Nous vous recommandons également de toujours prendre en compte les implications de sécurité lors de la création d’un service web XML. Pour plus d’informations sur la sécurisation d’un service web XML, consultez Sécurisation des services web XML créés à l’aide de ASP.NET.

Créer un service web XML

Créez le service Web XML.

Dans l’exemple, un service Web XML est créé qui retourne des données, dans ce cas une liste de clients de la base de données Northwind et reçoit un DataSet avec des mises à jour des données, que le service Web XML résout vers la source de données d’origine.

Le service Web XML expose deux méthodes : GetCustomers, pour renvoyer la liste des clients et UpdateCustomers, pour résoudre les mises à jour de la source de données. Le service web XML est stocké dans un fichier sur le serveur Web appelé DataSetSample.asmx. Le code suivant décrit le contenu de 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;  
  }  
}

Dans un scénario classique, la méthode UpdateCustomers est écrite pour intercepter les violations de concurrence optimistes. Par souci de simplicité, l’exemple n’inclut pas cela. Pour plus d’informations sur l’accès concurrentiel optimiste, consultez Accès concurrentiel optimiste.

Créez un proxy de service web XML.

Les clients du service web XML nécessitent un proxy SOAP pour consommer les méthodes exposées. Visual Studio peut générer ce proxy pour vous. En définissant une référence Web à un service Web existant à partir de Visual Studio, tout le comportement décrit dans cette étape se produit de manière transparente. Si vous souhaitez créer vous-même la classe proxy, poursuivez cette discussion. Toutefois, dans la plupart des cas, l’utilisation de Visual Studio pour créer la classe proxy pour l’application cliente est suffisante.

Un proxy peut être créé à l’aide de l’outil de langage de description des services web. Par exemple, si le service Web XML est exposé à l’URL http://myserver/data/DataSetSample.asmx, émettez une commande telle que la suivante pour créer un proxy .NET Visual Basic avec un espace de noms WebData.DSSample et stockez-le dans le fichier sample.vb.
```
wsdl /l:VB -out:sample.vb http://myserver/data/DataSetSample.asmx /n:WebData.DSSample  
```
Pour créer un proxy C# dans le fichier sample.cs, exécutez la commande suivante.
```
wsdl -l:CS -out:sample.cs http://myserver/data/DataSetSample.asmx -n:WebData.DSSample  
```
Le proxy peut ensuite être compilé en tant que bibliothèque et importé dans le client de service web XML. Pour compiler le code proxy Visual Basic .NET stocké dans sample.vb en tant que sample.dll, émettez la commande suivante.
```
vbc -t:library -out:sample.dll sample.vb -r:System.dll -r:System.Web.Services.dll -r:System.Data.dll -r:System.Xml.dll  
```
Pour compiler le code proxy C# stocké dans sample.cs en tant que sample.dll, émettez la commande suivante.
```
csc -t:library -out:sample.dll sample.cs -r:System.dll -r:System.Web.Services.dll -r:System.Data.dll -r:System.Xml.dll  
```
Créez un client de service web XML.

Si vous souhaitez que Visual Studio génère la classe proxy de service web pour vous, créez simplement le projet client et, dans la fenêtre Explorateur de solutions, cliquez avec le bouton droit sur le projet, puis sélectionnez Ajouter> uneréférence de service. Dans la boîte de dialogue Ajouter une référence de service , sélectionnez Avancé, puis Ajoutez une référence web. Sélectionnez le service Web dans la liste des services Web disponibles (cela peut nécessiter la fourniture de l’adresse du point de terminaison du service Web si le service Web n’est pas disponible dans la solution actuelle ou sur l’ordinateur actuel). Si vous créez vous-même le proxy de service web XML (comme décrit à l’étape précédente), vous pouvez l’importer dans votre code client et utiliser les méthodes de service web XML.

L’exemple de code suivant importe la bibliothèque proxy, appelle GetCustomers pour obtenir la liste des clients, ajoute un nouveau client, puis retourne un DataSet avec les mises à jour de UpdateCustomers.

L’exemple transmet le DataSet retourné par DataSet.GetChanges à UpdateCustomers, car seules les lignes modifiées doivent être passées à UpdateCustomers. UpdateCustomers retourne le DataSet résolu, que vous pouvez ensuite fusionner dans le DataSet existant pour incorporer les modifications résolues et toutes les informations d’erreur de ligne de la mise à jour. Le code suivant part du principe que vous avez utilisé Visual Studio pour créer la référence Web et que vous avez renommé la référence Web en DsSample dans la boîte de dialogue Ajouter une référence web .
```
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();  
  }  
}  
```
Si vous décidez de créer la classe proxy vous-même, vous devez effectuer les étapes supplémentaires suivantes. Pour compiler l’exemple, fournissez la bibliothèque proxy créée (sample.dll) et les bibliothèques .NET associées. Pour compiler la version Visual Basic .NET de l’exemple, stockée dans le fichier client.vb, émettez la commande suivante.
```
vbc client.vb -r:sample.dll -r:System.dll -r:System.Data.dll -r:System.Xml.dll -r:System.Web.Services.dll  
```
Pour compiler la version C# de l’exemple, stockée dans le fichier client.cs, émettez la commande suivante.
```
csc client.cs -r:sample.dll -r:System.dll -r:System.Data.dll -r:System.Xml.dll -r:System.Web.Services.dll  
```

Partager via

Consommer un DataSet à partir d’un service web XML

Créer un service web XML

Voir aussi

Ressources supplémentaires