Condividi tramite

Procedura: implementare un'operazione del servizio asincrona

  • Articolo

Nelle applicazioni Windows Communication Foundation (WCF), un'operazione del servizio può essere implementata in modo sincrono o asincrono senza imporre al client la modalità di chiamata. È possibile, ad esempio, che operazioni del servizio asincrone vengano chiamate in modo sincrono e che operazioni del servizio sincrone vengano chiamate in modo asincrono. Per un esempio in cui viene illustrato come chiamare in modo asincrono un'operazione in un'applicazione client, vedere Procedura: chiamare operazioni del servizio WCF in modo asincrono. Per ulteriori informazioni su lle operazioni sincrone e asincrone, vedere Progettazione dei contratti di servizio e Operazioni sincrone e asincrone. In questo argomento viene descritta la struttura di base di un'operazione del servizio asincrona (il codice non è completo). Per un esempio completo del client e del servizio, vedere Asincrono.

Implementazione di un'operazione del servizio in modo asincrono

  1. Nel contratto di servizio, dichiarare una coppia di metodi asincroni in base alle linee guida di progettazione asincrona .NET. Il metodo Begin prende un parametro, un oggetto callback e un oggetto di stato e restituisce un System.IAsyncResult e un metodo End corrispondente che prende un System.IAsyncResult e restituisce il valore restituito. Per ulteriori informazioni sulle chiamate asincrone, vedere Asynchronous Programming Design Patterns.

  2. Contrassegnare il metodo Begin della coppia di metodi asincroni con l'attributo System.ServiceModel.OperationContractAttribute e impostare la proprietà System.ServiceModel.OperationContractAttribute.AsyncPattern su true. Nel codice seguente, ad esempio, vengono eseguiti i passaggi 1 e 2.

      <OperationContractAttribute(AsyncPattern:=True)> _
  Function BeginServiceAsyncMethod(ByVal msg As String, ByVal callback As AsyncCallback, ByVal asyncState As Object) As IAsyncResult

  ' Note: There is no OperationContractAttribute for the end method.
  Function EndServiceAsyncMethod(ByVal result As IAsyncResult) As String
End Interface

      [OperationContractAttribute(AsyncPattern=true)]
  IAsyncResult BeginServiceAsyncMethod(string msg, AsyncCallback callback, object asyncState);

  // Note: There is no OperationContractAttribute for the end method.
  string EndServiceAsyncMethod(IAsyncResult result);
}

  3. Implementare la coppia di metodi Begin/End nella classe del servizio in base alle linee guida di progettazione asincrona. Nell'esempio di codice seguente viene illustrata un'implementazione nella quale una stringa viene scritta nella console sia nella parte Begin che nella parte End dell'operazione del servizio asincrona e viene restituito al client il valore restituito dell'operazione End. Per un esempio completo di codice, vedere la sezione degli esempi.

Esempio

Negli esempi di codice seguenti viene illustrato:

  1. Un'interfaccia del contratto di servizio con:

    1. Un'operazione SampleMethod sincrona.

    2. Un'operazione BeginSampleMethod asincrona.

    3. Una coppia di operazioni BeginServiceAsyncMethod/EndServiceAsyncMethod asincrone.

  2. Un'implementazione del servizio tramite un oggetto System.IAsyncResult.

Imports System
Imports System.Collections.Generic
Imports System.ServiceModel
Imports System.Text
Imports System.Threading

Namespace Microsoft.WCF.Documentation
  <ServiceContractAttribute(Namespace:="http://microsoft.wcf.documentation")> _
  Public Interface ISampleService

    <OperationContractAttribute> _
    Function SampleMethod(ByVal msg As String) As String

    <OperationContractAttribute(AsyncPattern := True)> _
    Function BeginSampleMethod(ByVal msg As String, ByVal callback As AsyncCallback, ByVal asyncState As Object) As IAsyncResult

    'Note: There is no OperationContractAttribute for the end method.
    Function EndSampleMethod(ByVal result As IAsyncResult) As String

    <OperationContractAttribute(AsyncPattern:=True)> _
    Function BeginServiceAsyncMethod(ByVal msg As String, ByVal callback As AsyncCallback, ByVal asyncState As Object) As IAsyncResult

    ' Note: There is no OperationContractAttribute for the end method.
    Function EndServiceAsyncMethod(ByVal result As IAsyncResult) As String
  End Interface

  Public Class SampleService
      Implements ISampleService
    #Region "ISampleService Members"

    Public Function SampleMethod(ByVal msg As String) As String Implements ISampleService.SampleMethod
      Console.WriteLine("Called synchronous sample method with ""{0}""", msg)
         Return "The sychronous service greets you: " & msg
    End Function

    ' This asynchronously implemented operation is never called because 
    ' there is a synchronous version of the same method.
    Public Function BeginSampleMethod(ByVal msg As String, ByVal callback As AsyncCallback, ByVal asyncState As Object) As IAsyncResult Implements ISampleService.BeginSampleMethod
      Console.WriteLine("BeginSampleMethod called with: " & msg)
      Return New CompletedAsyncResult(Of String)(msg)
    End Function

    Public Function EndSampleMethod(ByVal r As IAsyncResult) As String Implements ISampleService.EndSampleMethod
      Dim result As CompletedAsyncResult(Of String) = TryCast(r, CompletedAsyncResult(Of String))
      Console.WriteLine("EndSampleMethod called with: " & result.Data)
      Return result.Data
    End Function

    Public Function BeginServiceAsyncMethod(ByVal msg As String, ByVal callback As AsyncCallback, ByVal asyncState As Object) As IAsyncResult Implements ISampleService.BeginServiceAsyncMethod
      Console.WriteLine("BeginServiceAsyncMethod called with: ""{0}""", msg)
      Return New CompletedAsyncResult(Of String)(msg)
    End Function

    Public Function EndServiceAsyncMethod(ByVal r As IAsyncResult) As String Implements ISampleService.EndServiceAsyncMethod
      Dim result As CompletedAsyncResult(Of String) = TryCast(r, CompletedAsyncResult(Of String))
      Console.WriteLine("EndServiceAsyncMethod called with: ""{0}""", result.Data)
      Return result.Data
    End Function
    #End Region
  End Class

  ' Simple async result implementation.
  Friend Class CompletedAsyncResult(Of T)
      Implements IAsyncResult
    Private data_Renamed As T

    Public Sub New(ByVal data As T)
        Me.data_Renamed = data
    End Sub

    Public ReadOnly Property Data() As T
        Get
            Return data_Renamed
        End Get
    End Property

    #Region "IAsyncResult Members"
    Public ReadOnly Property AsyncState() As Object Implements IAsyncResult.AsyncState
        Get
            Return CObj(data_Renamed)
        End Get
    End Property

    Public ReadOnly Property AsyncWaitHandle() As WaitHandle Implements IAsyncResult.AsyncWaitHandle
        Get
            Throw New Exception("The method or operation is not implemented.")
        End Get
    End Property

    Public ReadOnly Property CompletedSynchronously() As Boolean Implements IAsyncResult.CompletedSynchronously
        Get
            Return True
        End Get
    End Property

    Public ReadOnly Property IsCompleted() As Boolean Implements IAsyncResult.IsCompleted
        Get
            Return True
        End Get
    End Property
    #End Region
  End Class
End Namespace

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Text;
using System.Threading;

namespace Microsoft.WCF.Documentation
{
  [ServiceContractAttribute(Namespace="http://microsoft.wcf.documentation")]
  public interface ISampleService{

    [OperationContractAttribute]
    string SampleMethod(string msg);

    [OperationContractAttribute(AsyncPattern = true)]
    IAsyncResult BeginSampleMethod(string msg, AsyncCallback callback, object asyncState);

    //Note: There is no OperationContractAttribute for the end method.
    string EndSampleMethod(IAsyncResult result);

    [OperationContractAttribute(AsyncPattern=true)]
    IAsyncResult BeginServiceAsyncMethod(string msg, AsyncCallback callback, object asyncState);

    // Note: There is no OperationContractAttribute for the end method.
    string EndServiceAsyncMethod(IAsyncResult result);
  }

  public class SampleService : ISampleService
  {
    #region ISampleService Members

    public string  SampleMethod(string msg)
    {
      Console.WriteLine("Called synchronous sample method with \"{0}\"", msg);
        return "The sychronous service greets you: " + msg;
    }

    // This asynchronously implemented operation is never called because 
    // there is a synchronous version of the same method.
    public IAsyncResult BeginSampleMethod(string msg, AsyncCallback callback, object asyncState)
    {
      Console.WriteLine("BeginSampleMethod called with: " + msg);
      return new CompletedAsyncResult<string>(msg);
    }

    public string EndSampleMethod(IAsyncResult r)
    {
      CompletedAsyncResult<string> result = r as CompletedAsyncResult<string>;
      Console.WriteLine("EndSampleMethod called with: " + result.Data);
      return result.Data;
    }

    public IAsyncResult BeginServiceAsyncMethod(string msg, AsyncCallback callback, object asyncState) 
    {
      Console.WriteLine("BeginServiceAsyncMethod called with: \"{0}\"", msg);
      return new CompletedAsyncResult<string>(msg);
    }

    public string EndServiceAsyncMethod(IAsyncResult r)
    {
      CompletedAsyncResult<string> result = r as CompletedAsyncResult<string>;
      Console.WriteLine("EndServiceAsyncMethod called with: \"{0}\"", result.Data);
      return result.Data;
    }
    #endregion
  }

  // Simple async result implementation.
  class CompletedAsyncResult<T> : IAsyncResult
  {
    T data;

    public CompletedAsyncResult(T data)
    { this.data = data; }

    public T Data
    { get { return data; } }

    #region IAsyncResult Members
    public object AsyncState
    { get { return (object)data; } }

    public WaitHandle AsyncWaitHandle
    { get { throw new Exception("The method or operation is not implemented."); } }

    public bool CompletedSynchronously
    { get { return true; } }

    public bool IsCompleted
    { get { return true; } }
    #endregion
  }
}

Vedere anche

Concetti

Progettazione dei contratti di servizio
Operazioni sincrone e asincrone