protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
{
return(SecurityUtil.ProcessInApplicationTrust(() =>
{
IController controller;
IControllerFactory factory;
ProcessRequestInit(httpContext, out controller, out factory);
IAsyncController asyncController = controller as IAsyncController;
if (asyncController != null)
{
// asynchronous controller
BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
{
try
{
return asyncController.BeginExecute(RequestContext, asyncCallback, asyncState);
}
catch
{
factory.ReleaseController(asyncController);
throw;
}
};
EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult)
{
try
{
asyncController.EndExecute(asyncResult);
}
finally
{
factory.ReleaseController(asyncController);
}
};
SynchronizationContext syncContext = SynchronizationContextUtil.GetSynchronizationContext();
AsyncCallback newCallback = AsyncUtil.WrapCallbackForSynchronizedExecution(callback, syncContext);
return AsyncResultWrapper.Begin(newCallback, state, beginDelegate, endDelegate, _processRequestTag);
}
else
{
// synchronous controller
Action action = delegate
{
try
{
controller.Execute(RequestContext);
}
finally
{
factory.ReleaseController(controller);
}
};
return AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag);
}
}));
}
protected internal virtual IAsyncResult BeginProcessRequest(
HttpContextBase httpContext,
AsyncCallback callback,
object state
)
{
IController controller;
IControllerFactory factory;
ProcessRequestInit(httpContext, out controller, out factory);
IAsyncController asyncController = controller as IAsyncController;
if (asyncController != null)
{
// asynchronous controller
// Ensure delegates continue to use the C# Compiler static delegate caching optimization.
BeginInvokeDelegate <ProcessRequestState> beginDelegate = delegate(
AsyncCallback asyncCallback,
object asyncState,
ProcessRequestState innerState
)
{
try
{
return(innerState.AsyncController.BeginExecute(
innerState.RequestContext,
asyncCallback,
asyncState
));
}
catch
{
innerState.ReleaseController();
throw;
}
};
EndInvokeVoidDelegate <ProcessRequestState> endDelegate = delegate(
IAsyncResult asyncResult,
ProcessRequestState innerState
)
{
try
{
innerState.AsyncController.EndExecute(asyncResult);
}
finally
{
innerState.ReleaseController();
}
};
ProcessRequestState outerState = new ProcessRequestState()
{
AsyncController = asyncController,
Factory = factory,
RequestContext = RequestContext
};
SynchronizationContext callbackSyncContext =
SynchronizationContextUtil.GetSynchronizationContext();
return(AsyncResultWrapper.Begin(
callback,
state,
beginDelegate,
endDelegate,
outerState,
_processRequestTag,
callbackSyncContext: callbackSyncContext
));
}
else
{
// synchronous controller
Action action = delegate
{
try
{
controller.Execute(RequestContext);
}
finally
{
factory.ReleaseController(controller);
}
};
return(AsyncResultWrapper.BeginSynchronous(
callback,
state,
action,
_processRequestTag
));
}
}
