Procedura: chiamare operazioni del servizio WCF in modo asincrono

In questo argomento viene illustrato come un client può accedere a un'operazione del servizio in modo asincrono. Il servizio in questo argomento implementa l'interfaccia ICalculator. Il client può chiamare le operazioni in questa interfaccia in modo asincrono utilizzando il modello di chiamata asincrono basato su eventi. (Per ulteriori informazioni sul modello di chiamata asincrono basato su eventi, vedere Multithreaded Programming with the Event-based Asynchronous Pattern). Per un esempio che illustra come implementare in modo asincrono un'operazione in un servizio, vedere Procedura: implementare un'operazione del servizio asincrona. Per ulteriori informazioni sulle operazioni sincrone e asincrone, vedere Operazioni sincrone e asincrone.

Nota:
Il modello di chiamata asincrono basato su eventi non è supportato quando si utilizza una classe ChannelFactory. Per ulteriori informazioni sulle chiamate asincrone utilizzando la classe ChannelFactory, vedere Procedura: chiamare le operazioni in modo asincrono tramite una channel factory.

Procedura

Per chiamare operazioni del servizio WCF in modo asincrono

1. Eseguire lo strumento Strumento ServiceModel Metadata Utility Tool (Svcutil.exe) con entrambe le opzioni di comando /async e /tcv:Version35 come illustrato nel comando seguente.

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

   Questa operazione genera, oltre alle operazioni sincrone e a quelle asincrone standard basate su delega, una classe client WCFcontenente:

   • Due operazioni <operationName>Async da utilizzare con l’approccio di chiamata asincrono basato su eventi. Ad esempio:

     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);
     }
     

   • Eventi completati dall'operazione del modulo <operationName>Completed da utilizzare con l’approccio di chiamata asincrono basato su eventi. Ad esempio:

     Public Event AddCompleted As System.EventHandler(Of AddCompletedEventArgs)
     

     public event System.EventHandler<AddCompletedEventArgs> AddCompleted;
     

   • Tipi System.EventArgs per ciascuna operazione (del modulo <operationName>CompletedEventArgs) da utilizzare con l’approccio di chiamata asincrono basato su eventi. Ad esempio:

     <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. Nell'applicazione chiamante creare un metodo di callback da chiamare al temine dell'operazione asincrona, come illustrato nel codice di esempio seguente.

   ' 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. Prima di chiamare l'operazione utilizzare un nuovo metodo System.EventHandler generico di tipo <operationName>EventArgs per aggiungere il metodo del gestore eventi (creato nel passaggio precedente) all'evento <operationName>Completed. Quindi chiamare il metodo <operationName>Async. Ad esempio:

   ' 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);
   

Esempio

Nota:

Le linee guida di progettazione per il modello asincrono basato su eventi indicano che, se vengono restituiti più valori, un valore viene restituito come proprietà Result e i restanti valori sono restituiti come proprietà nell’oggetto EventArgs. Di conseguenza, è possibile che, se un client importa metadati utilizzando le opzioni di comando asincrone basate su eventi e l'operazione restituisce più valori, l'oggetto predefinito EventArgs restituisce un valore come proprietà Result e i restanti valori come proprietà dell’oggetto EventArgs. Se si desidera ricevere l’oggetto del messaggio come proprietà Result e i valori restituiti come proprietà in quell’oggetto, utilizzare l’opzione di comando /messageContract. Questa operazione genera una firma che restituisce il messaggio di risposta come proprietà Result nell’oggetto EventArgs. Pertanto, tutti i valori restituiti interni sono proprietà dell’oggetto del messaggio di risposta.

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);
        }
    }
}

Vedere anche

Attività

Asincrono