void RequestCallback(IAsyncResult result)
            {
                if (result.CompletedSynchronously)
                {
                    return;
                }

                ChannelOpenAsyncResultWrapper wrapper = (ChannelOpenAsyncResultWrapper)result.AsyncState;

                object    requestState        = wrapper.RequestState;
                bool      completeSelf        = false;
                Exception completionException = null;

                try
                {
                    Message reply = this.channel.EndRequest(result);
                    completeSelf = this.OnReplyReceived(reply, requestState);
                    if (completeSelf)
                    {
                        this.OnOperationComplete();
                    }
                }
#pragma warning suppress 56500 // covered by FxCOP
                catch (Exception e)
                {
                    if (Fx.IsFatal(e))
                    {
                        throw;
                    }

                    completeSelf        = true;
                    completionException = e;
                    this.OnOperationFailure(e);
                }
                finally
                {
                    if (wrapper.Message != null)
                    {
                        wrapper.Message.Close();
                    }
                }

                if (completeSelf)
                {
                    Complete(false, completionException);
                }
            }
            bool OnChannelOpened()
            {
                object  requestState;
                Message requestMessage = this.requestor.CreateRequest(this.operation, this.target, this.currentToken, out requestState);

                if (requestMessage == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.NullSessionRequestMessage, this.operation.ToString())));
                }

                ChannelOpenAsyncResultWrapper wrapper = new ChannelOpenAsyncResultWrapper();

                wrapper.Message      = requestMessage;
                wrapper.RequestState = requestState;

                bool closeMessage = true;

                try
                {
                    IAsyncResult result = this.channel.BeginRequest(requestMessage, this.timeoutHelper.RemainingTime(), Fx.ThunkCallback(new AsyncCallback(this.RequestCallback)), wrapper);

                    if (!result.CompletedSynchronously)
                    {
                        closeMessage = false;
                        return(false);
                    }

                    Message reply = this.channel.EndRequest(result);
                    return(this.OnReplyReceived(reply, requestState));
                }
                finally
                {
                    if (closeMessage)
                    {
                        wrapper.Message.Close();
                    }
                }
            }