Vorgehensweise: Implementieren eines asynchronen Webdienstclients mithilfe der Rückruftechnik

Artikel
02/27/2011

Dieses Thema bezieht sich auf eine veraltete Technologie. XML-Webdienste und XML-Webdienstclients sollten nun mithilfe der folgenden Technologie erstellt werden: Windows Communication Foundation.

Die Rückruftechnik ist eine Möglichkeit zum Implementieren eines Webdienstclients, der asynchron mit einer Webdienstmethode kommuniziert, obwohl die Methode möglicherweise für den synchronen Zugriff gedacht ist. Die Technik wird im Thema "Asynchrones Kommunizieren mit XML-Webdiensten" erklärt.

Dieses Beispiel basiert auf der PrimeFactorizer-Webdienstklasse mit der Factorize-Methode, für die das Tool Wsdl.exe die beiden asynchronen Clientproxymethoden BeginFactorize und EndFactorize generiert hat.

So implementieren Sie die Rückruftechnik

Definieren Sie eine Rückruffunktion, die den AsyncCallback-Delegaten implementiert.

public static void FactorizeCallback(IAsyncResult ar)

Public Shared Sub FactorizeCallback(ar As IAsyncResult)

Instanziieren Sie den AsyncCallback-Delegaten.

AsyncCallback cb = new AsyncCallback(TestCallback.FactorizeCallback);

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

Rufen Sie die Begin-Methode auf, und übergeben Sie dabei die Rückruffunktion als zweites Argument und ein den Status bereitstellendes Objekt (in diesem Beispiel die Clientimplementierung von PrimeFactorizer) als drittes Argument.
```
IAsyncResult ar = pf.BeginFactorize(factorizableNum, cb, pf);
```
```
Dim ar As IAsyncResult = pf.BeginFactorize(factorizableNum, _
                                                     cb, pf)
```
Überprüfen Sie die IsCompleted-Eigenschaft des IAsyncResult-Objekts, das von der Begin-Methode zurückgegeben wird. Der Wert wird auf true festgelegt, nachdem der Client eine Antwort vom Server empfangen hat.
Greifen Sie in der Rückruffunktion auf das Statusobjekt zu. Das Objekt wird in der AsyncState-Eigenschaft des IAsyncState-Parameters als dritter Parameter für die Begin-Methode übergeben.
```
PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState;
```
```
Dim pf As PrimeFactorizer = ar.AsyncState
```
Rufen Sie in der Rückruffunktion die End-Methode für das Statusobjekt auf, das Sie im vorherigen Schritt erhalten haben.
```
long[] results = pf.EndFactorize(ar);
```
```
Dim results() as Long
results = pf.EndFactorize(ar)
```

Beispiel

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

Siehe auch

Freigeben über

Vorgehensweise: Implementieren eines asynchronen Webdienstclients mithilfe der Rückruftechnik

So implementieren Sie die Rückruftechnik

Beispiel

Siehe auch

Aufgaben

Konzepte

Weitere Ressourcen

Zusätzliche Ressourcen