Utilisation d'un DataSet à partir d'un service Web XML

Article
04/11/2008

Le 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 et le DataTable sont « sérialisables », en ce sens qu'ils peuvent être spécifiés en tant qu'entrée ou en tant que sortie de services Web XML sans qu'il soit nécessaire de leur ajouter du code pour transmettre le contenu du DataSet à partir d'un service Web XML vers un client et inversement. Le DataSet est implicitement converti en flux XML à l'aide du format DiffGram, envoyé sur le réseau, puis reconstruit sous forme de DataSet à 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, consultez DiffGrams.

L'exemple suivant illustre les étapes nécessaires à la création d'un service Web XML et d'un client pour ce service, qui utilisent le DataSet d'une part pour transporter des données relationnelles, ainsi que les modifications qui les concernent, et d'autre part pour répercuter les mises à jour dans la source de données d'origine.

Remarque Vous devez toujours tenir compte des impératifs de sécurité lorsque vous créez 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 d'ASP.NET.

Pour créer un service Web XML qui retourne et utilise un DataSet

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 DataSet 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 Web XML 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:="https://microsoft.com/webservices/")> _
Public Class Sample

  Public nwindConn As SqlConnection = New SqlConnection("Data Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind")

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

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

    GetCustomers = custDS
  End Function

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

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

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

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

    custDA.DeleteCommand = New SqlCommand("DELETE FROM Customers WHERE CustomerID = @CustomerID", nwindConn)
    myParm = custDA.DeleteCommand.Parameters.Add("@CustomerID", SqlDbType.NChar, 5, "CustomerID")
    myParm.SourceVersion = DataRowVersion.Original

    custDA.Update(custDS, "Customers")

    UpdateCustomers = custDS
  End Function
End Class
[C#]
<% @ WebService Language = "C#" Class = "Sample" %>
using System;
using System.Data;
using System.Data.SqlClient;
using System.Web.Services;

[WebService(Namespace="https://microsoft.com/webservices/")]
public class Sample
{
  public SqlConnection nwindConn = new SqlConnection("Data Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind");

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

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

    return custDS;
  }

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

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

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

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

    custDA.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 concurrentiel 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 auront besoin d'un proxy SOAP afin de pouvoir utiliser les méthodes exposées. Un proxy peut être créé à l'aide de l'outil Web Services Description Language Tool (Wsdl.exe). 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 ci-dessous.
```
wsdl /: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 ci-dessous.
```
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 ci-dessous.
```
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.

Après avoir créé le proxy du service Web XML, vous pouvez l'importer dans le code de votre client et utiliser les méthodes du 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 DataSet avec les mises à jour à UpdateCustomers. Notez que l'exemple passe le DataSet retourné par DataSet.GetChanges à UpdateCustomers parce que seules les lignes modifiées doivent être passées à UpdateCustomers. UpdateCustomers retourne le DataSet résolu, que vous pouvez ensuite fusionner avec le DataSet existant de façon à intégrer les modifications résolues et toute information d'erreur de ligne provenant de la mise à jour.

Imports System
Imports System.Data
Imports WebData.DSSample

Public Class Client

  Public Shared Sub Main()
    Dim mySamp As Sample = New Sample()  ' Proxy object.

    Dim myDS As DataSet = mySamp.GetCustomers()

    Dim myTable As DataTable = myDS.Tables("Customers")

    Dim newRow As DataRow = myTable.NewRow()
    newRow("CustomerID") = "ABCDE"
    newRow("CompanyName") = "New Company Name"
    myTable.Rows.Add(newRow)

    Dim updDS As DataSet = mySamp.UpdateCustomers(myDS.GetChanges())

    myDS.Merge(updDS)
    myDS.AcceptChanges()
  End Sub
End Class
[C#]
using System;
using System.Data;
using WebData.DSSample;

public class Client
{
  public static void Main()
  {
    Sample mySamp = new Sample();  // Proxy object.

    DataSet myDS = mySamp.GetCustomers();

    DataTable myTable = myDS.Tables["Customers"];

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

    DataSet updDS = new DataSet();

    updDS = mySamp.UpdateCustomers(myDS.GetChanges());

    myDS.Merge(updDS);
    myDS.AcceptChanges();
  }
}

Pour compiler l'exemple, vous devez fournir 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 ci-dessous.

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 ci-dessous.

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

Voir aussi

Exemples de scénarios ADO.NET | Accès aux données avec ADO.NET | Utilisation des fournisseurs de données .NET Framework pour l'accès aux données | Création et utilisation de DataSets | Création et utilisation de DataTables | Remplissage d'un DataSet à partir d'un DataAdapter | Mise à jour de la base de données avec un DataAdapter et le DataSet | Utilisation des paramètres avec un DataAdapter

Partager via

Utilisation d'un DataSet à partir d'un service Web XML

Voir aussi

Ressources supplémentaires