Ottenere risposta dal Castello Wcf struttura chiamata asincrona

Question

Di 'Ho una chiamata in questo modo:

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

Come faccio ad avere la risposta del SaveAct? Come posso impostare una richiamata a fuoco quando i completa l'operazione?

ho provato:

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

                                                                    }, _actService);

Ma si lamenta una chiamata ambigua?

Tutti gli indicatori?

Answer 1

Craig Neuwirt risposto questo: http://groups.google .com / gruppo / castello-progetto-utenti / browse_thread / thread / f440dbd05e60484f

Penso che si può essere un po 'confuso circa la normale C # asincrona modello. Si comporta sempre un paio di Begin chiamate / End.

I modelli WCF Struttura di supporto 2 di callback che è determinato dalle ultime 2 argomenti del vostro BeginWcfCall

Le 2 opzioni sono   1) Azione>, Stato   2) AsyncCallback, stato

L'opzione 1 è il modello asincrono di serie e sarebbe simile a questa

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

Come si può vedere, il primo richiede un riferimento al proxy _actService a fine chiamata. Il primo è un metodo comodo, che non lo fa.

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

La scelta di quale approccio dipende interamente dalla vostra preferenza del c # modello asincrono standard.