Discussion :

[Arnard]

Bonjour,

j'ai un bout de code WCF qui envoie une commande à un serveur, ce dernier répond par une callback si réponse il y a, générant côté client un événement.

J'aimerais refaire ce fonctionnel avec un task await, il existe un pattern pour intégrer mon existant où je dois revoir ma logique de code ?

Merci

[Arnard]

Je continue mes recherches à ce sujet.

Il existe Task.Factory.FromAsync qui permet de passer un couple de Begin/End méthodes, mais je pêche à coller ça avec mon modèle d'événements

[worm83]

Bonjour,

j'ai un bout de code WCF qui envoie une commande à un serveur, ce dernier répond par une callback si réponse il y a, générant côté client un événement.

J'aimerais refaire ce fonctionnel avec un task await, il existe un pattern pour intégrer mon existant où je dois revoir ma logique de code ?

Merci

Je répondrais, un peu des deux XD.

Il te suffit juste de retourner l'objet Task, par exemple en incluant en plus le pattern "async/await" , avec un exemple idiot:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
      public Task<string> DoIt()
        {
            return Task<string>.Factory.StartNew(() =>
              {
                  var retour = "";
                  for (int i = 0; i < 10000; i++) //Ici on a l'appel à ton service
                  {
                      retour = i.ToString();
 
                  }
                  return retour; ;
              });
 
        }
 
 
        public async void WaitDoIt()
        {
            var test = await DoIt();
        }

Je suppose que c'est ce que tu voulais faire. Désolé si j'ai mal compris.

[GuruuMeditation]

Voila un exemple d'utilisation de FromAsync avec un memorystream (le principe est le même)

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
var memoryStream = new MemoryStream();
 
 
var buffer = new byte[100];
 
 
var bytesread = await Task<int>.Factory.FromAsync(memoryStream.BeginRead, memoryStream.EndRead, buffer, 0, buffer.Length,null);

Il faut lui passer la méthode begin, celle end, et les paramètres de la méthode begin (plus un objet state, qui est ici a null)

[Arnard]

Je vais rajouter du code histoire d'être moins obscur ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
class Client : ICallback //décrit la callback depuis le service WCF
{
    //Appelle le serviuce WCF pour envoyer la commande chez le client
    public void SendCommand(Command cmd)
    {
        monServiceWCF.SendCommand(cmd);
    }
 
    public EventHandler<ResultCommandEventArgs> OnResultFired;
 
    [OperationContract(IsOneWay = true)] // de l'interface ICallback, je le colle ici pour description
    public void FireResult(ResultCommand res)  
    {
        if(OnResultFired != null)
              OnResultFired(ResultCommandEventArgs(res));
    }
}

Usage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Client monClient  = ...
monClient.OnResultFired += processResult;
 
 
/// Later ///
monClient.SendCommand(cmd);

Donc j'ia un appel sans retour, et le résultat revient par une callback. Le client ne bloque pas et peut exploiter quand il a besoin.

Et là je me dis, que SendCommand puisse me renvoyer le résultat en async (y'a un scénario qui m'intéresse pour), ce serait cool, histoire de traiter les données à la chaine. Je me disais donc qu'une Task qui englobe le call, et qui peut gérer le callback en une seule méthode, ce serait chouette. Mais je ne vois pas comment faire. Arriver à quelque chose du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ResultCommand res = await monclient.SendCommandAsync(cmd);

Dans l'idée, il faudrait que le processus qui fait l'appel WCF se mette en attente de l'occurence de l'événement, pour ensuite renvoyer la valeur.

Le FromAsync me semblait ok pour intégrer le système, mais il faudrait que le EndInvoke soit en attente de l'événement retour, et puisse l'interpréter, et je ne vois pas comment le faire (vu que par essence l'événement appelle son propre délégué); Donc je ne suis pas sûr que FromAsync soit la bonne chose

En un sens je pense que je tente un truc foireux, mais en même temps la curiosité me pousse à trouver une solution élégante

[GuruuMeditation]

Tu as regardé les TaskCompletionSource (https://msdn.microsoft.com/en-us/lib...=vs.110).aspx) ?

Ca donnerais un truc du genre (super simplifié, il faudrait associé un TCS à chaque requête et faire le lien avec quel TCS correspond le FireResult):

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class Client : ICallback //décrit la callback depuis le service WCF
{
    private TaskCompletionSource<object> _tcs; 
   public Task<object> SendCommandAsync(Command cmd)
   {
            _tcs = new TaskCompletionSource<object>();
            monServiceWCF.SendCommand(cmd);
            return _tcs.Task;
   }
 
   [OperationContract(IsOneWay = true)] // de l'interface ICallback, je le colle ici pour description
   public void FireResult(ResultCommand res)
   {
            _tcs.SetResult(res);
   }
}

[Arnard]

Mais ça me semble matcher à mon besoin, excellent. Je vais faire un peu de code pour enrober tout ça, mais le mécanisme me convient

MERCI !