Conseguir la respuesta del castillo de WCF instalación llamada asincrónica

Question

Decir que tengo una llamada de este modo:

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

¿Cómo llego a la respuesta de SaveAct? ¿Cómo puedo configurar una devolución de llamada de fuego cuando se complete la operación?

He intentado:

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

                                                                    }, _actService);

Pero se queja de una llamada ambigua?

Cualquier punteros?

Answer 1

Craig Neuwirt respondió esto: http://groups.google .com / grupo / castillo del proyecto a los usuarios / browse_thread / hilo / f440dbd05e60484f

Creo que puede ser un poco confuso sobre el patrón normal de C # asíncrono. Es siempre implican un par de comenzar / finalizar llamadas.

Los modelos de devolución de llamada de WCF servicio de apoyo 2 que está determinada por los últimos 2 argumentos de su BeginWcfCall

Las opciones son 2 1) Acción>, el estado 2) AsyncCallback, estado

La opción 1 es el patrón asincrónico estándar y se vería así

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

Como se puede ver, el primero requiere una referencia al proxy _actService a fin de la llamada. El primero es un método de conveniencia que no lo hace.

 _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 elección del método que depende totalmente de su preferencia del patrón asincrónico estándar C #.