protected internal virtual ActionExecutedContext EndInvokeActionMethodWithFilters(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.End <ActionExecutedContext>(asyncResult, _invokeActionMethodWithFiltersTag));
}
public virtual bool EndInvokeAction(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.End <bool>(asyncResult, _invokeActionTag));
}
protected internal virtual ActionResult EndInvokeActionMethod(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.End <ActionResult>(asyncResult, _invokeActionMethodTag));
}
private IAsyncResult BeginInvokeSynchronousActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters, AsyncCallback callback, object state)
{
return(AsyncResultWrapper.BeginSynchronous(callback, state,
() => InvokeSynchronousActionMethod(controllerContext, actionDescriptor, parameters),
_invokeActionMethodTag));
}
public virtual IAsyncResult BeginInvokeAction(ControllerContext controllerContext, string actionName, AsyncCallback callback, object state)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
if (String.IsNullOrEmpty(actionName))
{
throw Error.ParameterCannotBeNullOrEmpty("actionName");
}
ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);
if (actionDescriptor != null)
{
FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
Action continuation = null;
BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
{
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 = () => InvokeActionResult(controllerContext, authContext.Result);
}
else
{
if (controllerContext.Controller.ValidateRequest)
{
ValidateRequest(controllerContext);
}
IDictionary <string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
IAsyncResult asyncResult = BeginInvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters, asyncCallback, asyncState);
continuation = () =>
{
ActionExecutedContext postActionContext = EndInvokeActionMethodWithFilters(asyncResult);
InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, postActionContext.Result);
};
return(asyncResult);
}
}
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(BeginInvokeAction_MakeSynchronousAsyncResult(asyncCallback, asyncState));
};
EndInvokeDelegate <bool> endDelegate = delegate(IAsyncResult asyncResult)
{
try
{
continuation();
}
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;
}
InvokeActionResult(controllerContext, exceptionContext.Result);
}
return(true);
};
return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeActionTag));
}
else
{
// Notify the controller that no action was found.
return(BeginInvokeAction_ActionNotFound(callback, state));
}
}
public override object EndExecute(IAsyncResult asyncResult)
{
return(AsyncResultWrapper.End <object>(asyncResult, _executeTag));
}
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 asyncManager = GetAsyncManager(controllerContext.Controller);
BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
{
// call the XxxAsync() method
ParameterInfo[] parameterInfos = AsyncMethodInfo.GetParameters();
var rawParameterValues = from parameterInfo in parameterInfos
select ExtractParameterFromDictionary(parameterInfo, parameters, AsyncMethodInfo);
object[] parametersArray = rawParameterValues.ToArray();
TriggerListener listener = new TriggerListener();
SimpleAsyncResult asyncResult = new SimpleAsyncResult(asyncState);
// hook the Finished event to notify us upon completion
Trigger finishTrigger = listener.CreateTrigger();
asyncManager.Finished += delegate
{
finishTrigger.Fire();
};
asyncManager.OutstandingOperations.Increment();
// to simplify the logic, force the rest of the pipeline to execute in an asynchronous callback
listener.SetContinuation(() => ThreadPool.QueueUserWorkItem(_ => asyncResult.MarkCompleted(false /* completedSynchronously */, asyncCallback)));
// the inner operation might complete synchronously, so all setup work has to be done before this point
ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(AsyncMethodInfo);
dispatcher.Execute(controllerContext.Controller, parametersArray); // ignore return value from this method
// now that the XxxAsync() method has completed, kick off any pending operations
asyncManager.OutstandingOperations.Decrement();
listener.Activate();
return(asyncResult);
};
EndInvokeDelegate <object> endDelegate = delegate(IAsyncResult asyncResult)
{
// call the XxxCompleted() method
ParameterInfo[] completionParametersInfos = CompletedMethodInfo.GetParameters();
var rawCompletionParameterValues = from parameterInfo in completionParametersInfos
select ExtractParameterOrDefaultFromDictionary(parameterInfo, asyncManager.Parameters);
object[] completionParametersArray = rawCompletionParameterValues.ToArray();
ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(CompletedMethodInfo);
object actionReturnValue = dispatcher.Execute(controllerContext.Controller, completionParametersArray);
return(actionReturnValue);
};
return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _executeTag, asyncManager.Timeout));
}
protected internal virtual IAsyncResult BeginInvokeActionMethodWithFilters(
ControllerContext controllerContext,
IList <IActionFilter> filters,
ActionDescriptor actionDescriptor,
IDictionary <string, object> parameters,
AsyncCallback callback,
object state
)
{
Func <ActionExecutedContext> endContinuation = null;
BeginInvokeDelegate beginDelegate = delegate(
AsyncCallback asyncCallback,
object asyncState
)
{
AsyncInvocationWithFilters invocation = new AsyncInvocationWithFilters(
this,
controllerContext,
actionDescriptor,
filters,
parameters,
asyncCallback,
asyncState
);
const int StartingFilterIndex = 0;
endContinuation = invocation.InvokeActionMethodFilterAsynchronouslyRecursive(
StartingFilterIndex
);
if (invocation.InnerAsyncResult != null)
{
// we're just waiting for the inner result to complete
return(invocation.InnerAsyncResult);
}
else
{
// something was short-circuited and the action was not called, so this was a synchronous operation
SimpleAsyncResult newAsyncResult = new SimpleAsyncResult(asyncState);
newAsyncResult.MarkCompleted(
completedSynchronously: true,
callback: asyncCallback
);
return(newAsyncResult);
}
};
EndInvokeDelegate <ActionExecutedContext> endDelegate = delegate(
IAsyncResult asyncResult
)
{
return(endContinuation());
};
return(AsyncResultWrapper.Begin(
callback,
state,
beginDelegate,
endDelegate,
_invokeActionMethodWithFiltersTag
));
}
