réponse Obtenir du château WCF établissement appel async

Question

Dire que j'ai un appel comme ceci:

 _actService.BeginWcfCall(x => x.SaveAct(new SaveActRequest
                                                             {
                                                                 Act = act
                                                             }));

Comment puis-je obtenir la réponse de SaveAct? Comment puis-je mettre en place un rappel au feu lorsque les finalise de fonctionnement?

J'ai essayé:

    _actService.BeginWcfCall(x => x.GetAct(new GetActRequest
                                                            {
                                                                ActName =
                                                                    saveScheduleSlotRequest.ScheduleSlot.ActProxy.Name
                                                            }), (result) =>
                                                                    {
                                                                        var async = (GetActResponse)result.AsyncState;

                                                                    }, _actService);

Mais il se plaint d'un appel ambigu?

Les pointeurs?

Answer 1

Craig Neuwirt a répondu ceci: http://groups.google .com / groupe / château-projet-utilisateurs / browse_thread / fil / f440dbd05e60484f

Je pense que vous pouvez être un peu confus au sujet de la normale C # async. Il implique toujours une paire de Begin appels / fin.

Le soutien MFA 2 modèles de rappel qui est déterminé par les 2 derniers arguments de votre BeginWcfCall

Les 2 options sont   1) action>, l'état   2) AsyncCallback, état

L'option 1 est le modèle standard et async ressemblerait à ceci

     _actService.BeginWcfCall(x => x.GetAct(new GetActRequest 
                                                            { 
                                                                ActName = 
                                                                    saveScheduleSlotRequest.ScheduleSlot.ActProxy.Name 
                                                            }), (IAsyncResult result) => 
                                                                    { 
                                                                        var response =  _actService.EndWcfCall<GetActResponse>(result); 
                                                                        // Do something with the response 
                                                                    }); 

Comme vous pouvez le voir, la première demande une référence au proxy _actService à la fin d'appel. La première est une méthode pratique qui ne fonctionne pas.

 _actService.BeginWcfCall(x => x.GetAct(new GetActRequest 
                                                            { 
                                                                ActName = 
                                                                    saveScheduleSlotRequest.ScheduleSlot.ActProxy.Name 
                                                            }), (IWcfAsyncCall<GetActResponse> result) => 
                                                                    { 
                                                                        var response =  result.End(); 
                                                                        // Do something with the response 
                                                                    }); 

Le choix de l'approche dépend entièrement de votre préférence du c # modèle standard async.