Comment : appeler des opérations de façon asynchrone à l'aide d'une fabrication de canal

Article
02/27/2011

Cette rubrique décrit comment un client peut accéder de façon asynchrone à une opération de service lors de l'utilisation d'une application cliente basée sur ChannelFactory. (Lors de l'utilisation d'un objet System.ServiceModel.ClientBase pour appeler un service, vous pouvez utiliser le modèle d'appel asynchrone commandé par événement. Pour plus d'informations, consultez Comment : appeler des opérations de service WCF de façon asynchrone. Pour plus d'informations sur l'utilisation du modèle d'appel asynchrone basé sur événement, consultez Multithreaded Programming with the Event-based Asynchronous Pattern.

Le service dans cette rubrique implémente l'interface ICalculator. Le client peut appeler les opérations sur cette interface de façon asynchrone, ce qui signifie que des opérations telles que Add sont divisées en deux méthodes : BeginAdd et EndAdd, la première initiant l'appel et la seconde récupérant le résultat au terme de l'opération. Pour obtenir un exemple illustrant comment implémenter une opération de façon asynchrone dans un service, consultez Comment : implémenter une opération de service asynchrone. Pour plus d'informations sur les opérations synchrones et asynchrones, consultez Opérations synchrones et asynchrones.

Procédure

Pour appeler des opérations de service WCF de façon asynchrone

Exécutez l'outil Outil Service Model Metadata Tool (Svcutil.exe) en définissant l'option /async tel qu'affichée dans la commande suivante.
```
svcutil /n:http://Microsoft.ServiceModel.Samples,Microsoft.ServiceModel.Samples https://localhost:8000/servicemodelsamples/service/mex /a
```
Cela génère une version cliente asynchrone du contrat de service pour l'opération.

Créez une fonction de rappel à appeler au terme de l'opération asynchrone en vous conformant à l'exemple de code suivant.

Private Shared Sub AddCallback(ByVal ar As IAsyncResult)
    Dim result = (CType(ar.AsyncState, CalculatorClient)).EndAdd(ar)
    Console.WriteLine("Add Result: {0}", result)
End Sub

static void AddCallback(IAsyncResult ar)
{
    double result = ((CalculatorClient)ar.AsyncState).EndAdd(ar);
    Console.WriteLine("Add Result: {0}", result);
}

Pour accéder de façon asynchrone à une opération de service, créez le client, puis appelez la méthode Begin[Operation] (par exemple, BeginAdd) et spécifiez une fonction de rappel en vous conformant à l'exemple de code suivant.

Dim factory As New ChannelFactory(Of ICalculatorChannel)()
Dim channelClient As ICalculatorChannel = factory.CreateChannel()

' BeginAdd
  Dim value1 = 100.0R
  Dim value2 = 15.99R

Dim arAdd As IAsyncResult = channelClient.BeginAdd(value1, value2, AddressOf AddCallback, channelClient)
Console.WriteLine("Add({0},{1})", value1, value2)

ChannelFactory<ICalculatorChannel> factory = new ChannelFactory<ICalculatorChannel>();
ICalculatorChannel channelClient = factory.CreateChannel();

// BeginAdd
double value1 = 100.00D;
double value2 = 15.99D;

IAsyncResult arAdd = channelClient.BeginAdd(value1, value2, AddCallback, channelClient);
Console.WriteLine("Add({0},{1})", value1, value2);

Lors de l'exécution de la fonction de rappel, le client appelle la méthode End<operation> (par exemple, EndAdd) pour récupérer le résultat.

Exemple

Le service utilisé avec le code client utilisé dans la procédure précédente implémente l'interface ICalculator comme affiché dans le code suivant. Du côté service, les opérations Add et Subtract du contrat sont appelées de façon synchrone par le temps d'exécution Windows Communication Foundation (WCF), bien que les étapes clientes précédentes soient appelées de façon asynchrone sur le client. Les opérations Multiply et Divide sont utilisées pour appeler de façon asynchrone le service du côté service, même si le client les appelle de façon synchrone. Cet exemple affecte la propriété AsyncPattern à true. Ce paramètre de propriété, ainsi que l'implémentation du modèle asynchrone du .NET Framework indiquent au temps d'exécution d'appeler l'opération de façon asynchrone.

<ServiceContract(Namespace := "http://Microsoft.ServiceModel.Samples")> _
Public Interface ICalculator
    <OperationContract> _
    Function Add(ByVal n1 As Double, ByVal n2 As Double) As Double

    <OperationContract> _
    Function Subtract(ByVal n1 As Double, ByVal n2 As Double) As Double

    'Multiply involves some file I/O so we'll make it Async.
    <OperationContract(AsyncPattern := True)> _
    Function BeginMultiply(ByVal n1 As Double, ByVal n2 As Double, ByVal callback As AsyncCallback, ByVal state As Object) As IAsyncResult
    Function EndMultiply(ByVal ar As IAsyncResult) As Double

    'Divide involves some file I/O so we'll make it Async.
    <OperationContract(AsyncPattern := True)> _
    Function BeginDivide(ByVal n1 As Double, ByVal n2 As Double, ByVal callback As AsyncCallback, ByVal state As Object) As IAsyncResult
    Function EndDivide(ByVal ar As IAsyncResult) As Double
End Interface

[ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]
public interface ICalculator
{
    [OperationContract]
    double Add(double n1, double n2);

    [OperationContract]
    double Subtract(double n1, double n2);

    //Multiply involves some file I/O so we'll make it Async.
    [OperationContract(AsyncPattern = true)]
    IAsyncResult BeginMultiply(double n1, double n2, AsyncCallback callback, object state);
    double EndMultiply(IAsyncResult ar);

    //Divide involves some file I/O so we'll make it Async.
    [OperationContract(AsyncPattern = true)]
    IAsyncResult BeginDivide(double n1, double n2, AsyncCallback callback, object state);
    double EndDivide(IAsyncResult ar);
}

Voir aussi

Tâches

Asynchronous

Partager via