private static IAsyncResult ActionNotFound(AsyncCallback callback, object state) { BeginInvokeDelegate beginDelegate = MakeSynchronousAsyncResult; EndInvokeDelegate <bool> endDelegate = delegate(IAsyncResult asyncResult) { return(false); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeTag)); }
protected virtual IAsyncResult BeginProcessRequest( HttpContextBase context, AsyncCallback callback, object state) { AppendVersionHeader(context); string controllerName = Context.RouteData.GetRequiredValue <string>("controller"); IControllerFactory factory = Builder.GetControllerFactory(); IController controller = factory.CreateController(Context, controllerName); if (controller == null) { throw Error.CouldNotCreateController(controllerName); } IAsyncController asyncController = (controller as IAsyncController); if (asyncController == null) // synchronous controller { Action action = delegate { try { controller.Execute(Context); } finally { factory.ReleaseController(controller); } }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _tag)); } // asynchronous controller BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { try { return(asyncController.BeginExecute(Context, asyncCallback, asyncState)); } finally { factory.ReleaseController(asyncController); } }; EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult) { try { asyncController.EndExecute(asyncResult); } finally { factory.ReleaseController(asyncController); } }; return(AsyncResultWrapper.Begin(AsyncTask.WrapCallbackForSynchronizedExecution(callback, SynchronizationContextExtensions.GetSynchronizationContext()), state, beginDelegate, endDelegate, _tag)); }
protected virtual IAsyncResult BeginExecute(RequestContext context, AsyncCallback callback, object state) { Precondition.Require(context, () => Error.ArgumentNull("context")); VerifyExecuteCalledOnce(); Initialize(context); return(AsyncResultWrapper.Begin(callback, state, OnBeginExecute, OnEndExecute, _executeTag)); }
private IAsyncResult BeginInvokeAsynchronousActionMethod(ControllerContext context, AsyncActionDescriptor action, IDictionary <string, object> parameters, AsyncCallback callback, object state) { BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { return(action.BeginExecute(context, parameters, asyncCallback, asyncState)); }; EndInvokeDelegate <ActionResult> endDelegate = delegate(IAsyncResult asyncResult) { object returnValue = action.EndExecute(asyncResult); ActionResult result = CreateActionResult(context, action, returnValue); return(result); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeMethodTag)); }
public override IAsyncResult BeginExecute(ControllerContext context, IDictionary <string, object> parameters, AsyncCallback callback, object state) { Precondition.Require(context, () => Error.ArgumentNull("context")); Precondition.Require(parameters, () => Error.ArgumentNull("parameters")); AsyncManager asyncManager = GetAsyncManager(context.Controller); BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { object[] parameterValues = _entryMethod.GetParameters() .Select(p => ExtractParameter(p, parameters, _entryMethod)) .ToArray(); TriggerListener listener = new TriggerListener(); MvcAsyncResult asyncResult = new MvcAsyncResult(asyncState); Trigger finishTrigger = listener.CreateTrigger(); asyncManager.Finished += delegate { finishTrigger.Fire(); }; asyncManager.OutstandingOperations.Increment(); listener.SetContinuation(() => ThreadPool.QueueUserWorkItem(_ => asyncResult.MarkCompleted(false, asyncCallback))); DispatcherCache.GetDispatcher(_entryMethod) .Execute(context.Controller, parameterValues); asyncManager.OutstandingOperations.Decrement(); listener.Activate(); return(asyncResult); }; EndInvokeDelegate <object> endDelegate = delegate(IAsyncResult asyncResult) { object[] parameterValues = _completedMethod.GetParameters() .Select(p => ExtractParameter(p, parameters, _completedMethod)) .ToArray(); return(DispatcherCache.GetDispatcher(_completedMethod) .Execute(context.Controller, parameterValues)); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _executeTag, asyncManager.Timeout)); }
protected virtual IAsyncResult OnBeginExecute(AsyncCallback callback, object state) { LoadTempData(); try { string actionName = RouteData.GetRequiredValue <string>("action"); IActionExecutor executor = ActionExecutor; IAsyncActionExecutor asyncExecutor = (executor as IAsyncActionExecutor); if (asyncExecutor != null) { BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { return(asyncExecutor.BeginInvokeAction(Context, actionName, asyncCallback, asyncState, new ValueDictionary())); }; EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult) { if (!asyncExecutor.EndInvokeAction(asyncResult)) { HandleUnknownAction(actionName); } }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _tag)); } else { Action action = () => { if (!executor.InvokeAction(Context, actionName, null)) { HandleUnknownAction(actionName); } }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _tag)); } } catch { SaveTempData(); throw; } }
protected virtual IAsyncResult BeginInvokeActionFilters(ControllerContext context, ActionDescriptor action, ICollection <IActionFilter> filters, IDictionary <string, object> parameters, AsyncCallback callback, object state) { Func <ActionExecutedContext> endContinuation = null; BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { ActionExecutionContext preContext = new ActionExecutionContext(context, action); IAsyncResult innerAsyncResult = null; Func <Func <ActionExecutedContext> > beginContinuation = () => { innerAsyncResult = BeginInvokeActionMethod(context, action, parameters, asyncCallback, asyncState); return(() => new ActionExecutedContext(preContext, null) { Result = EndInvokeActionMethod(innerAsyncResult) }); }; Func <Func <ActionExecutedContext> > thunk = filters.Reverse().Aggregate(beginContinuation, (next, filter) => () => InvokeActionFilterAsynchronously(filter, preContext, next)); endContinuation = thunk(); if (innerAsyncResult != null) { return(innerAsyncResult); } else { MvcAsyncResult newAsyncResult = new MvcAsyncResult(asyncState); newAsyncResult.MarkCompleted(true, asyncCallback); return(newAsyncResult); } }; EndInvokeDelegate <ActionExecutedContext> endDelegate = delegate(IAsyncResult asyncResult) { return(endContinuation()); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeMethodFiltersTag)); }
protected virtual IAsyncResult BeginProcessRequest( HttpContextBase context, AsyncCallback callback, object state) { IHttpHandler handler = GetHttpHandler(context); IHttpAsyncHandler asyncHandler = (handler as IHttpAsyncHandler); if (asyncHandler == null) { Action action = delegate { handler.ProcessRequest(context.Unwrap()); }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _tag)); } BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { return(asyncHandler.BeginProcessRequest(context.Unwrap(), asyncCallback, asyncState)); }; EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult) { asyncHandler.EndProcessRequest(asyncResult); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _tag)); }
public IAsyncResult BeginInvokeAction(ControllerContext context, string actionName, AsyncCallback callback, object state, IDictionary <string, object> values) { Precondition.Require(context, () => Error.ArgumentNull("context")); Precondition.Defined(actionName, () => Error.ArgumentNull("actionName")); ControllerDescriptor controller = GetControllerDescriptor(context); ActionDescriptor action = controller.FindAction(context, actionName); if (action == null) { return(ActionNotFound(callback, state)); } context.Parameters.Merge(GetParameterValues(context, action)) .Merge(values); ActionFilterInfo filters = GetFilters(context, action); Action continuation = null; BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { try { AuthorizationContext authContext = InvokeAuthorizationFilters(context, action, filters.AuthorizationFilters); if (authContext.Cancel) { continuation = () => InvokeActionResult(context, authContext.Result ?? EmptyResult.Instance); } else { if (context.Controller.ValidateRequest) { ValidateRequest(context.Context.Request); } IAsyncResult asyncResult = BeginInvokeActionFilters(context, action, filters.ActionFilters, context.Parameters, asyncCallback, asyncState); continuation = () => { ActionExecutedContext postContext = EndInvokeActionFilters(asyncResult); InvokeActionResultFilters(context, filters.ResultFilters, postContext.Result); }; return(asyncResult); } } catch (ThreadAbortException) { throw; } catch (Exception ex) { ExceptionContext ctx = InvokeExceptionFilters(context, ex, filters.ExceptionFilters); if (!ctx.Handled) { throw; } continuation = () => InvokeActionResult(context, ctx.Result); } return(MakeSynchronousAsyncResult(asyncCallback, asyncState)); }; EndInvokeDelegate <bool> endDelegate = delegate(IAsyncResult asyncResult) { try { continuation(); } catch (ThreadAbortException) { throw; } catch (Exception ex) { ExceptionContext ctx = InvokeExceptionFilters(context, ex, filters.ExceptionFilters); if (!ctx.Handled) { throw; } InvokeActionResult(context, ctx.Result); } return(true); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeTag)); }