Procedura: Implementare un client di servizio Web asincrono tramite la tecnica di callback

Articolo
09/01/2008

La tecnica di callback costituisce un modo per implementare un client di servizio Web per comunicare in modo asincrono con un metodo di servizio Web, anche se il metodo può essere pensato per un accesso sincrono. La tecnica viene spiegata nell'argomento Comunicazione asincrona con i servizi Web XML.

Questo esempio è basato su una classe di servizio Web PrimeFactorizer con un metodo Factorizeper il quale lo strumento Wsdl.exe ha generato due metodi del proxy client asincroni, BeginFactorize e EndFactorize.

Per implementare la tecnica di callback

Definire una funzione di callback che implementa il delegato di AsyncCallback.

public static void FactorizeCallback(IAsyncResult ar)

Public Shared Sub FactorizeCallback(ar As IAsyncResult)

Creare un'istanza del delegato di AsyncCallback.

AsyncCallback cb = new AsyncCallback(TestCallback.FactorizeCallback);

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

Chiamare il metodo Begin, passando la funzione callback come secondo argomento e un oggetto che fornisce lo stato (in questo esempio, l'implementazione client di PrimeFactorizer) come terzo argomento.
```
IAsyncResult ar = pf.BeginFactorize(factorizableNum, cb, pf);
```
```
Dim ar As IAsyncResult = pf.BeginFactorize(factorizableNum, _
                                                     cb, pf)
```
Controllare la proprietà IsCompleted nell'IAsyncResult restituito dal metodo Begin. Il valore viene impostato su true dopo che il client ha ricevuto una risposta dal server.
All'interno della funzione di callback, accedere all'oggetto di stato. L'oggetto della proprietà AsyncState del parametro IAsyncState viene passato come terzo parametro al metodo Begin.
```
PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState;
```
```
Dim pf As PrimeFactorizer = ar.AsyncState
```
All'interno della funzione di callback, chiamare il metodo End sull'oggetto di stato ottenuto nel passaggio precedente.
```
long[] results = pf.EndFactorize(ar);
```
```
Dim results() as Long
results = pf.EndFactorize(ar)
```

Esempio

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

Vedere anche

Footer image

Condividi tramite

Procedura: Implementare un client di servizio Web asincrono tramite la tecnica di callback

Per implementare la tecnica di callback

Esempio

Vedere anche

Attività

Concetti

Altre risorse

Risorse aggiuntive