Comment : implémenter un client de service Web asynchrone à l'aide de la technique de rappel

Article
04/22/2008

La technique de rappel est un moyen d'implémenter un client de service Web pour communiquer de façon asynchrone avec une méthode de service Web, même si la méthode est prévue pour un accès synchrone. La technique est expliquée dans la rubrique Communiquer de façon asynchrone avec les services Web XML.

Cet exemple se base sur une classe de service Web PrimeFactorizer avec une méthode Factorize, pour laquelle l'outil Wsdl.exe a généré deux méthodes de proxy clientes asynchrones, BeginFactorize et EndFactorize.

Pour implémenter la technique de rappel

Définissez une fonction de rappel qui implémente le délégué AsyncCallback.

public static void FactorizeCallback(IAsyncResult ar)

Public Shared Sub FactorizeCallback(ar As IAsyncResult)

Instanciez le délégué AsyncCallback.

AsyncCallback cb = new AsyncCallback(TestCallback.FactorizeCallback);

Dim cb as AsyncCallback 
cb = new AsyncCallback(AddressOf TestCallback.FactorizeCallback)

Appelez la méthode Begin, en passant la fonction de rappel comme deuxième argument et un objet fournissant l'état (dans cet exemple, l'implémentation cliente de PrimeFactorizer) comme troisième argument.
```
IAsyncResult ar = pf.BeginFactorize(factorizableNum, cb, pf);
```
```
Dim ar As IAsyncResult = pf.BeginFactorize(factorizableNum, _
                                                     cb, pf)
```
Vérifiez la propriété IsCompleted sur l' IAsyncResult retourné par la méthode Begin. La valeur est définie sur true une fois que le client a reçu une réponse du serveur.
Dans la fonction de rappel, accédez à l'objet d'état. La propriété AsyncState du paramètre IAsyncState fait passer l'objet comme troisième paramètre pour la méthode Begin.
```
PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState;
```
```
Dim pf As PrimeFactorizer = ar.AsyncState
```
Dans la fonction de rappel, appelez la méthode End sur l'objet d'état obtenu à l'étape précédente.
```
long[] results = pf.EndFactorize(ar);
```
```
Dim results() as Long
results = pf.EndFactorize(ar)
```

Exemple

using System;
using System.Runtime.Remoting.Messaging;
using MyFactorize;

class TestCallback
 {           
      public static void Main(){
            long factorizableNum = 12345;
            PrimeFactorizer pf = new PrimeFactorizer();

            //Instantiate an AsyncCallback delegate to use as a parameter
            //in the BeginFactorize method.
            AsyncCallback cb = new AsyncCallback(TestCallback.FactorizeCallback);

          // Begin the Async call to Factorize, passing in our
          // AsyncCalback delegate and a reference
          // to our instance of PrimeFactorizer.
            IAsyncResult ar = pf.BeginFactorize(factorizableNum, cb, pf);
            
            // Keep track of the time it takes to complete the async call
            // as the call proceeds.
         int start = DateTime.Now.Second;
         int currentSecond = start;
         while (!ar.IsCompleted){
            if (currentSecond < DateTime.Now.Second) {
                  currentSecond = DateTime.Now.Second;
                  Console.WriteLine("Seconds Elapsed..." + (currentSecond - start).ToString() );
            }
         }
         // Once the call has completed, you need a method to ensure the
         // thread executing this Main function 
         // doesn't complete prior to the call-back function completing.
         Console.Write("Press Enter to quit");
         int quitchar = Console.Read();
      }
      // Set up a call-back function that is invoked by the proxy class
      // when the asynchronous operation completes.
      public static void FactorizeCallback(IAsyncResult ar)
      {
          // You passed in our instance of PrimeFactorizer in the third
          // parameter to BeginFactorize, which is accessible in the
          // AsyncState property.
          PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState;
          long[] results;

          // Get the completed results.
            results = pf.EndFactorize(ar);
          
          //Output the results.
            Console.Write("12345 factors into: ");
            int j;
            for (j = 0; j<results.Length;j++){
                  if (j == results.Length - 1)
                      Console.WriteLine(results[j]);
                  else 
                      Console.Write(results[j] + ", ");
            }
      }
}

Imports System
Imports System.Runtime.Remoting.Messaging
Imports MyFactorize

Public Class TestCallback
    Public Shared Sub Main()
       Dim factorizableNum As Long = 12345
       Dim pf As PrimeFactorizer = new PrimeFactorizer()

       'Instantiate an AsyncCallback delegate to use as a 
       'parameter
       ' in the BeginFactorize method.
       Dim cb as AsyncCallback 
       cb = new AsyncCallback(AddressOf TestCallback.FactorizeCallback)

     ' Begin the Async call to Factorize, passing in the
     ' AsyncCallback delegate and a reference to our instance
     ' of PrimeFactorizer.
       Dim ar As IAsyncResult = pf.BeginFactorize(factorizableNum, _
                                                     cb, pf)
            
     ' Keep track of the time it takes to complete the async call as
     ' the call proceeds.
       Dim start As Integer = DateTime.Now.Second
       Dim currentSecond As Integer = start
       Do while (ar.IsCompleted = false)
          If (currentSecond < DateTime.Now.Second) Then
                currentSecond = DateTime.Now.Second
                Console.WriteLine("Seconds Elapsed..." + 
                      (currentSecond - start).ToString() )
          End If
       Loop

      ' Once the call has completed, you need a method to ensure the
      ' thread executing this Main function 
      ' doesn't complete prior to the callback function completing.
       Console.Write("Press Enter to quit")
       Dim quitchar As Integer = Console.Read()
    End Sub

    ' Set up the call-back function that is invoked by the proxy 
    ' class when the asynchronous operation completes.
    Public Shared Sub FactorizeCallback(ar As IAsyncResult)
    
       ' You passed in the instance of PrimeFactorizer in the third
       ' parameter to BeginFactorize, which is accessible in the
       ' AsyncState property.
         Dim pf As PrimeFactorizer = ar.AsyncState
         Dim results() as Long

       ' Get the completed results.
         results = pf.EndFactorize(ar)
        
       'Output the results.
         Console.Write("12345 factors into: ")
         Dim j as Integer
         For j = 0 To results.Length - 1
              If  j = (results.Length - 1) Then
                   Console.WriteLine(results(j) )
              Else 
                   Console.Write(results(j).ToString + ", ")
              End If
        Next j         
     End Sub      
End Class

Voir aussi

Footer image

Partager via

Comment : implémenter un client de service Web asynchrone à l'aide de la technique de rappel

Pour implémenter la technique de rappel

Exemple

Voir aussi

Tâches

Concepts

Autres ressources

Ressources supplémentaires