public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary <string, object> parameters, AsyncCallback callback, object state)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
AsyncManager asyncHelper = GetAsyncManager(controllerContext.Controller);
SingleFireEvent setupCompletedEvent = new SingleFireEvent();
BeginInvokeCallback beginCallback = (innerCallback, innerState) => {
ManualAsyncResult asyncResult = new ManualAsyncResult()
{
AsyncState = innerState
};
// Get parameters for async setup method, then execute
ParameterInfo[] setupParametersInfos = SetupMethod.GetParameters();
var rawSetupParameterValues = from parameterInfo in setupParametersInfos
select ExtractParameterFromDictionary(parameterInfo, parameters, SetupMethod);
object[] setupParametersArray = rawSetupParameterValues.ToArray();
// to simplify the logic, force an asynchronous callback
asyncHelper.OutstandingOperations.Completed += delegate {
if (setupCompletedEvent.Signal())
{
ThreadPool.QueueUserWorkItem(o => {
asyncResult.MarkCompleted(false /* completedSynchronously */, innerCallback);
});
}
};
MethodDispatcher setupDispatcher = DispatcherCache.GetDispatcher(SetupMethod);
asyncHelper.OutstandingOperations.Increment();
setupDispatcher.Execute(controllerContext.Controller, setupParametersArray);
asyncHelper.OutstandingOperations.Decrement();
return(asyncResult);
};
AsyncCallback <object> endCallback = ar => {
if (setupCompletedEvent.Signal())
{
// the setup method did not complete before this callback executed
throw new InvalidOperationException(MvcResources.AsyncActionDescriptor_EndExecuteCalledPrematurely);
}
// Get parameters for action method, then execute
ParameterInfo[] completionParametersInfos = CompletionMethod.GetParameters();
var rawCompletionParameterValues = from parameterInfo in completionParametersInfos
select ExtractParameterOrDefaultFromDictionary(parameterInfo, asyncHelper.Parameters);
object[] completionParametersArray = rawCompletionParameterValues.ToArray();
MethodDispatcher completionDispatcher = DispatcherCache.GetDispatcher(CompletionMethod);
object actionReturnValue = completionDispatcher.Execute(controllerContext.Controller, completionParametersArray);
return(actionReturnValue);
};
// Set the timeout and go
int timeout = asyncHelper.Timeout;
return(AsyncResultWrapper.WrapWithTimeout(callback, state, beginCallback, endCallback, timeout, _executeTag));
}
public IAsyncResult ToAsyncResultWrapper(AsyncCallback callback, object state)
{
return(AsyncResultWrapper.Wrap <T>(callback, state, BeginInvoke, EndInvoke));
}
public override object EndExecute(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.UnwrapAndContinue <object>(asyncResult, _executeTag));
}
protected internal virtual ActionExecutedContext EndInvokeActionMethodWithFilters(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.UnwrapAndContinue <ActionExecutedContext>(asyncResult, _invokeActionMethodWithFiltersTag));
}
public virtual IAsyncResult BeginInvokeAction(ControllerContext controllerContext, string actionName, AsyncCallback callback, object state)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (String.IsNullOrEmpty(actionName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);
if (actionDescriptor == null)
{
// notify controller that no method matched
return(CreateInvokeActionNotFoundAsyncResult(callback, state));
}
Action continuation;
FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
try {
AuthorizationContext authContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor);
if (authContext.Result != null)
{
// the auth filter signaled that we should let it short-circuit the request
continuation = () => {
BeginInvokeActionEndContinuation(controllerContext, filterInfo.ExceptionFilters, () => {
InvokeActionResult(controllerContext, authContext.Result);
});
};
}
else
{
if (controllerContext.Controller.ValidateRequest)
{
ValidateRequest(controllerContext.HttpContext.Request);
}
IDictionary <string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
return(AsyncResultWrapper.Wrap(callback, state,
(innerCallback, innerState) => BeginInvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters, innerCallback, innerState),
ar => {
BeginInvokeActionEndContinuation(controllerContext, filterInfo.ExceptionFilters, () => {
ActionExecutedContext postActionContext = EndInvokeActionMethodWithFilters(ar);
InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result);
});
return true;
},
_invokeActionTag));
}
}
catch (ThreadAbortException) {
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
throw;
}
catch (Exception ex) {
// something blew up, so execute the exception filters
ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex);
if (!exceptionContext.ExceptionHandled)
{
throw;
}
continuation = () => InvokeActionResult(controllerContext, exceptionContext.Result);
}
return(CreateInvokeActionContinuationAsyncResult(callback, state, continuation));
}
internal static ActionExecutedContext EndInvokeActionMethodFilter(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.UnwrapAndContinue <ActionExecutedContext>(asyncResult));
}
protected internal virtual ActionResult EndInvokeActionMethod(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.UnwrapAndContinue <ActionResult>(asyncResult, _invokeActionMethodTag));
}
public virtual bool EndInvokeAction(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.UnwrapAndContinue <bool>(asyncResult, _invokeActionTag));
}
protected internal virtual void EndExecuteCore(IAsyncResult asyncResult)
{
AsyncResultWrapper.UnwrapAndContinue(asyncResult, _executeCoreTag);
}
protected virtual void EndProcessRequest(IAsyncResult result)
{
AsyncResultWrapper.UnwrapAndContinue(result, _processRequestTag);
}