Vorgehensweise: Asynchrones Aufrufen von WCF-Dienstvorgängen

In diesem Thema wird beschrieben, wie ein Client auf einen Dienstvorgang asynchron zugreifen kann. Der in diesem Thema behandelte Dienst implementiert die ICalculator-Schnittstelle. Der Client kann mithilfe des ereignisgesteuerten asynchronen Aufrufmodells die Vorgänge asynchron an dieser Schnittstelle aufrufen. (Weitere Informationen zur Verwendung des ereignisgesteuerten asynchronen Aufrufmodells finden Sie unter Multithreaded Programming with the Event-based Asynchronous Pattern.) Ein Beispiel für das asynchrone Implementieren eines Vorgangs in einem Dienst finden Sie unter Vorgehensweise: Implementieren eines asynchronen Dienstvorgangs. Weitere Informationen zu synchronen und asynchronen Vorgängen finden Sie unter Synchrone und asynchrone Vorgänge.

Hinweis:
Bei Verwendung einer ChannelFactory wird das ereignisgesteuerte asynchrone Aufrufmodell nicht unterstützt. Weitere Informationen zur Verwendung asynchroner Aufrufe mit ChannelFactory finden Sie unter Vorgehensweise: Asynchrones Aufrufen von Vorgängen mit einer Kanalfactory.

Vorgehensweise

So rufen Sie WCF-Dienstvorgänge asynchron auf

1. Führen Sie das Tool ServiceModel Metadata Utility-Tool (Svcutil.exe) unter Angabe der beiden Befehlsoptionen /async und /tcv:Version35 wie in folgendem Befehl dargestellt aus.

   svcutil /n:http://Microsoft.ServiceModel.Samples,Microsoft.ServiceModel.Samples https://localhost:8000/servicemodelsamples/service/mex /a /tcv:Version35
   

   Damit wird neben den synchronen Vorgängen und den standardmäßigen delegatenbasierten asynchronen Vorgängen eine WCF-Clientklasse erstellt, die Folgendes enthält:

   • Zwei <operationName>Async-Vorgänge zur Verwendung mit dem ereignisbasierten asynchronen Aufrufmodell. Beispiel:

     Public Overloads Sub AddAsync(ByVal n1 As Double, ByVal n2 As Double)
         Me.AddAsync(n1, n2, Nothing)
     End Sub
     
     Public Overloads Sub AddAsync(ByVal n1 As Double, ByVal n2 As Double, ByVal userState As Object)
         If (Me.onBeginAddDelegate Is Nothing) Then
             Me.onBeginAddDelegate = AddressOf Me.OnBeginAdd
         End If
         If (Me.onEndAddDelegate Is Nothing) Then
             Me.onEndAddDelegate = AddressOf Me.OnEndAdd
         End If
         If (Me.onAddCompletedDelegate Is Nothing) Then
             Me.onAddCompletedDelegate = AddressOf Me.OnAddCompleted
         End If
         MyBase.InvokeAsync(Me.onBeginAddDelegate, New Object() {n1, n2}, Me.onEndAddDelegate, Me.onAddCompletedDelegate, userState)
     End Sub
     

     public void AddAsync(double n1, double n2)
     {
         this.AddAsync(n1, n2, null);
     }
     
     public void AddAsync(double n1, double n2, object userState)
     {
         if ((this.onBeginAddDelegate == null))
         {
             this.onBeginAddDelegate = new BeginOperationDelegate(this.OnBeginAdd);
         }
         if ((this.onEndAddDelegate == null))
         {
             this.onEndAddDelegate = new EndOperationDelegate(this.OnEndAdd);
         }
         if ((this.onAddCompletedDelegate == null))
         {
             this.onAddCompletedDelegate = new System.Threading.SendOrPostCallback(this.OnAddCompleted);
         }
         base.InvokeAsync(this.onBeginAddDelegate, new object[] {
                     n1,
                     n2}, this.onEndAddDelegate, this.onAddCompletedDelegate, userState);
     }
     

   • Ereignisse, die nach Beendigung des Vorgangs ausgelöst werden und das Format <operationName>Completed haben, zur Verwendung mit dem ereignisbasierten asynchronen Aufrufmodell. Beispiel:

     Public Event AddCompleted As System.EventHandler(Of AddCompletedEventArgs)
     

     public event System.EventHandler<AddCompletedEventArgs> AddCompleted;
     

   • System.EventArgs-Typen für jeden Vorgang (im Format <operationName>CompletedEventArgs) zur Verwendung mit dem ereignisbasierten asynchronen Aufrufmodell. Beispiel:

     <System.Diagnostics.DebuggerStepThroughAttribute(),  _
      System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")>  _
     Partial Public Class AddCompletedEventArgs
         Inherits System.ComponentModel.AsyncCompletedEventArgs
     
         Private results() As Object
     
         Public Sub New(ByVal results() As Object, ByVal exception As System.Exception, ByVal cancelled As Boolean, ByVal userState As Object)
             MyBase.New(exception, cancelled, userState)
             Me.results = results
         End Sub
     
         Public ReadOnly Property Result() As Double
             Get
                 MyBase.RaiseExceptionIfNecessary
                 Return CType(Me.results(0),Double)
             End Get
         End Property
     End Class
     

     [System.Diagnostics.DebuggerStepThroughAttribute()]
     [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
     public partial class AddCompletedEventArgs : System.ComponentModel.AsyncCompletedEventArgs
     {
         private object[] results;
     
         public AddCompletedEventArgs(object[] results, System.Exception exception, bool cancelled, object userState) : 
                 base(exception, cancelled, userState)
         {       this.results = results;         }
     
         public double Result
         {
             get            {
                 base.RaiseExceptionIfNecessary();
                 return ((double)(this.results[0]));
             }
         }
     }
     

2. Erstellen Sie in der aufrufenden Anwendung eine Rückrufmethode, die aufgerufen wird, wenn der asynchrone Vorgang abgeschlossen ist, wie im folgenden Beispielcode dargestellt.

   ' Asynchronous callbacks for displaying results.
   Private Shared Sub AddCallback(ByVal sender As Object, ByVal e As AddCompletedEventArgs)
   
       Console.WriteLine("Add Result: {0}", e.Result)
   
   End Sub
   

   // Asynchronous callbacks for displaying results.
   static void AddCallback(object sender, AddCompletedEventArgs e)
   {
       Console.WriteLine("Add Result: {0}", e.Result);
   }
   

3. Vor dem Aufruf des Vorgangs verwenden Sie einen generischen System.EventHandler vom Typ <operationName>EventArgs, um die Handlermethode (die im vorigen Schritt erstellt wurde) dem <operationName>Completed-Ereignis hinzuzufügen. Dann rufen Sie die <operationName>Async-Methode auf. Beispiel:

   ' AddAsync
   Dim value1 As Double = 100
   Dim value2 As Double = 15.99
   AddHandler client.AddCompleted, AddressOf AddCallback
   client.AddAsync(value1, value2)
   Console.WriteLine("Add({0},{1})", value1, value2)
   

   // AddAsync
   double value1 = 100.00D;
   double value2 = 15.99D;
   client.AddCompleted += new EventHandler<AddCompletedEventArgs>(AddCallback);
   client.AddAsync(value1, value2);
   Console.WriteLine("Add({0},{1})", value1, value2);
   

Beispiel

Hinweis:

Die Entwurfsrichtlinien für das ereignisbasierte asynchrone Modell besagen, dass in den Fällen, in denen mehr als ein Wert zurückgegeben wird, ein Wert in der Result-Eigenschaft und die übrigen Werte in Eigenschaften des EventArgs-Objekts zurückgegeben werden sollen. Wenn ein Client Metadaten mithilfe der ereignisbasierten asynchronen Befehlsoptionen importiert und der Vorgang mehr als einen Wert zurückgibt, dann gibt das EventArgs-Objekt infolgedessen einen Wert in der Result-Eigenschaft zurück, und die übrigen Werte werden in Eigenschaften des EventArgs-Objekts zurückgegeben. Wenn das Nachrichtenobjekt in der Result-Eigenschaft und die Rückgabewerte als Eigenschaften dieses Objekts übermittelt werden sollen, verwenden Sie die Befehlsoption /messageContract. Damit wird eine Signatur generiert, bei der die Antwortnachricht in der Result-Eigenschaft des EventArgs-Objekts zurückgegeben wird. Alle internen Rückgabewerte sind dann Eigenschaften des Antwortnachrichtenobjekts.

Imports System

Namespace Microsoft.ServiceModel.Samples

    ' The service contract is defined in generatedClient.vb, generated from the service by the svcutil tool.

    Class Client

        Public Shared Sub Main()

            Console.WriteLine("Press <ENTER> to terminate client once the output is displayed.")
            Console.WriteLine()

            ' Create a client
            Dim client As New CalculatorClient()

            ' AddAsync
            Dim value1 As Double = 100
            Dim value2 As Double = 15.99
            AddHandler client.AddCompleted, AddressOf AddCallback
            client.AddAsync(value1, value2)
            Console.WriteLine("Add({0},{1})", value1, value2)

            ' SubtractAsync
            value1 = 145
            value2 = 76.54
            AddHandler client.SubtractCompleted, AddressOf SubtractCallback
            client.SubtractAsync(value1, value2)
            Console.WriteLine("Subtract({0},{1})", value1, value2)

            ' Multiply
            value1 = 9
            value2 = 81.25
            Dim result As Double = client.Multiply(value1, value2)
            Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result)

            ' Divide
            value1 = 22
            value2 = 7
            result = client.Divide(value1, value2)
            Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result)
            Console.ReadLine()

            'Closing the client gracefully closes the connection and cleans up resources
            client.Close()

        End Sub
        ' Asynchronous callbacks for displaying results.
        Private Shared Sub AddCallback(ByVal sender As Object, ByVal e As AddCompletedEventArgs)

            Console.WriteLine("Add Result: {0}", e.Result)

        End Sub
        Private Shared Sub SubtractCallback(ByVal sender As Object, ByVal e As SubtractCompletedEventArgs)

            Console.WriteLine("Subtract Result: {0}", e.Result)

        End Sub

    End Class

End Namespace

using System;

namespace Microsoft.ServiceModel.Samples
{
    // The service contract is defined in generatedClient.cs, generated from the service by the svcutil tool.

    class Client
    {
        static void Main()
        {
            Console.WriteLine("Press <ENTER> to terminate client once the output is displayed.");
            Console.WriteLine();

            // Create a client
            CalculatorClient client = new CalculatorClient();

            // AddAsync
            double value1 = 100.00D;
            double value2 = 15.99D;
            client.AddCompleted += new EventHandler<AddCompletedEventArgs>(AddCallback);
            client.AddAsync(value1, value2);
            Console.WriteLine("Add({0},{1})", value1, value2);

            // SubtractAsync
            value1 = 145.00D;
            value2 = 76.54D;
            client.SubtractCompleted += new EventHandler<SubtractCompletedEventArgs>(SubtractCallback);
            client.SubtractAsync(value1, value2);
            Console.WriteLine("Subtract({0},{1})", value1, value2);

            // Multiply
            value1 = 9.00D;
            value2 = 81.25D;
            double result = client.Multiply(value1, value2);
            Console.WriteLine("Multiply({0},{1}) = {2}", value1, value2, result);

            // Divide
            value1 = 22.00D;
            value2 = 7.00D;
            result = client.Divide(value1, value2);
            Console.WriteLine("Divide({0},{1}) = {2}", value1, value2, result);

            Console.ReadLine();

            //Closing the client gracefully closes the connection and cleans up resources
            client.Close();
        }

        // Asynchronous callbacks for displaying results.
        static void AddCallback(object sender, AddCompletedEventArgs e)
        {
            Console.WriteLine("Add Result: {0}", e.Result);
        }

        static void SubtractCallback(object sender, SubtractCompletedEventArgs e)
        {
            Console.WriteLine("Subtract Result: {0}", e.Result);
        }
    }
}

Siehe auch

Aufgaben

Asynchron