Consommation d’un jeu de données à partir d’un service web XML

Article
05/10/2023

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 jeu de données est « sérialisable », en ce sens qu’il peut être spécifié en tant qu’entrée ou en tant que sortie de services web XML sans qu’il soit nécessaire d’ajouter du code pour transmettre le contenu du DataSet à partir d’un service web XML vers un client et inversement. Le jeu de données est implicitement converti en flux XML à l’aide du format DiffGram, envoyé sur le réseau, puis reconstruit sous forme de jeu de données à partir du flux XML au point de réception. Vous disposez ainsi d’une méthode alliant simplicité et souplesse pour la transmission et le retour de données relationnelles à l’aide des services web XML. Pour plus d’informations sur le format DiffGram, voir DiffGrams.

L’exemple suivant montre comment créer un service web XML et un client qui utilisent le jeu de données pour transporter des données relationnelles (notamment des données modifiées) et pour répercuter les mises à jour dans la source de données d’origine.

Notes

La transmission des instances DataSet ou DataTable dans le cadre des appels de service Web XML n’est pas sécurisée si l’entrée n’est pas approuvée. Pour plus d’informations, consultez les conseils de sécurité DataSet et DataTable. Nous recommandons également de toujours tenir compte des impératifs de sécurité lorsque vous créez un service Web XML. Pour plus d’informations sur la sécurité du service web XML, consultez Sécuriser les services web XML créés avec ASP.NET.

Créer un service web XML

Créez le service web XML.

Dans l’exemple, un service web XML est créé. Il retourne des données, dans ce cas, une liste de clients provenant de la base de données Northwind, et reçoit un jeu de données avec des mises à jour relatives aux données, que le service web XML répercute dans la source de données d’origine.

Le service XML web expose deux méthodes : GetCustomers, pour retourner la liste des clients, et UpdateCustomers, pour répercuter les mises à jour dans la source de données. Le service Web XML est stocké sur le serveur Web dans le fichier DataSetSample.asmx. Le code suivant représente le contenu de ce fichier.

<% @ 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 serait écrite de façon à intercepter les violations d’accès simultané optimiste. Par souci de simplicité, cet exemple ne le fait pas. 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 ont besoin d’un proxy SOAP pour pouvoir utiliser les méthodes exposées. Vous pouvez faire en sorte que Visual Studio génère ce proxy pour vous. En définissant une référence Web à un service Web existant depuis Visual Studio, tout le comportement décrit dans cette étape se passe de façon transparente. Si vous souhaitez créer la classe proxy vous-même, passez à cette description. Le plus souvent, cependant, l'utilisation de Visual Studio pour créer la classe proxy pour l'application cliente suffit.

Un proxy peut être créé à l'aide de l'outil Web Services Description Language Tool. Par exemple, si le service web XML est exposé à l’URL http://myserver/data/DataSetSample.asmx, écrivez une commande semblable à celle qui suit pour créer un proxy Visual Basic .NET 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, écrivez 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 du service web XML. Pour compiler le code Visual Basic .NET du proxy stocké dans sample.vb en tant que sample.dll, écrivez 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 C# du proxy stocké dans sample.cs en tant que sample.dll, écrivez 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>Référence de service. Dans la boîte de dialogue Ajouter une référence de service, cliquez sur Avancé, puis cliquez sur Ajouter 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 n’est pas disponible dans la solution actuelle ou sur l’ordinateur actuel). Si vous créez le proxy de service Web XML vous-même (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 du proxy, appelle GetCustomers pour obtenir une liste de clients, ajoute un nouveau client, puis retourne un jeu de données avec les mises à jour dans UpdateCustomers.

L’exemple passe le jeu de données retourné par DataSet.GetChanges à UpdateCustomers parce que seules les lignes modifiées doivent être passées à UpdateCustomers. UpdateCustomers retourne le jeu de données résolu, que vous pouvez ensuite fusionner avec le jeu de données existant de façon à intégrer les modifications résolues et toute information d’erreur de ligne provenant de la mise à jour. Le code suivant est basé sur l’hypothèse 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 prendre les mesures supplémentaires suivantes. Pour compiler l'exemple, fournissez la bibliothèque de proxy qui a été créée (sample.dll) ainsi que les bibliothèques .NET connexes. Pour compiler la version Visual Basic .NET de l'exemple, stockée dans le fichier client.vb, écrivez 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, écrivez 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  
```

Consommation d’un jeu de données à partir d’un service web XML

Créer un service web XML

Voir aussi

Ressources supplémentaires