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 virtual IAsyncResult BeginExecute(RequestContext requestContext, AsyncCallback callback, object state) { if (DisableAsyncSupport) { // For backwards compat, we can disallow async support and just chain to the sync Execute() function. Action action = () => { Execute(requestContext); }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _executeTag)); } else { if (requestContext == null) { throw new ArgumentNullException("requestContext"); } // Support Asynchronous behavior. // Execute/ExecuteCore are no longer called. VerifyExecuteCalledOnce(); Initialize(requestContext); return(AsyncResultWrapper.Begin(callback, state, BeginExecuteCore, EndExecuteCore, _executeTag)); } }
protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state) { IHttpHandler httpHandler = GetHttpHandler(httpContext); IHttpAsyncHandler httpAsyncHandler = httpHandler as IHttpAsyncHandler; if (httpAsyncHandler != null) { // asynchronous handler BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { return(httpAsyncHandler.BeginProcessRequest(HttpContext.Current, asyncCallback, asyncState)); }; EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult) { httpAsyncHandler.EndProcessRequest(asyncResult); }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _processRequestTag)); } else { // synchronous handler Action action = delegate { httpHandler.ProcessRequest(HttpContext.Current); }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag)); } }
protected internal virtual IAsyncResult BeginProcessRequest( HttpContextBase httpContext, AsyncCallback callback, object state ) { IHttpHandler httpHandler = GetHttpHandler(httpContext); IHttpAsyncHandler httpAsyncHandler = httpHandler as IHttpAsyncHandler; if (httpAsyncHandler != null) { // asynchronous handler // Ensure delegates continue to use the C# Compiler static delegate caching optimization. BeginInvokeDelegate <IHttpAsyncHandler> beginDelegate = delegate( AsyncCallback asyncCallback, object asyncState, IHttpAsyncHandler innerHandler ) { return(innerHandler.BeginProcessRequest( HttpContext.Current, asyncCallback, asyncState )); }; EndInvokeVoidDelegate <IHttpAsyncHandler> endDelegate = delegate( IAsyncResult asyncResult, IHttpAsyncHandler innerHandler ) { innerHandler.EndProcessRequest(asyncResult); }; return(AsyncResultWrapper.Begin( callback, state, beginDelegate, endDelegate, httpAsyncHandler, _processRequestTag )); } else { // synchronous handler Action action = delegate { httpHandler.ProcessRequest(HttpContext.Current); }; return(AsyncResultWrapper.BeginSynchronous( callback, state, action, _processRequestTag )); } }
protected virtual IAsyncResult BeginExecute( RequestContext requestContext, AsyncCallback callback, object state ) { if (DisableAsyncSupport) { // For backwards compat, we can disallow async support and just chain to the sync Execute() function. Action action = () => { Execute(requestContext); }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _executeTag)); } else { if (requestContext == null) { throw new ArgumentNullException("requestContext"); } // Support Asynchronous behavior. // Execute/ExecuteCore are no longer called. VerifyExecuteCalledOnce(); Initialize(requestContext); // Ensure delegates continue to use the C# Compiler static delegate caching optimization. BeginInvokeDelegate <Controller> beginDelegate = ( AsyncCallback asyncCallback, object callbackState, Controller controller ) => { return(controller.BeginExecuteCore(asyncCallback, callbackState)); }; EndInvokeVoidDelegate <Controller> endDelegate = ( IAsyncResult asyncResult, Controller controller ) => { controller.EndExecuteCore(asyncResult); }; return(AsyncResultWrapper.Begin( callback, state, beginDelegate, endDelegate, this, _executeTag )); } }
public void BeginSynchronous_Func() { // Act IAsyncResult asyncResult = AsyncResultWrapper.BeginSynchronous(null, null, () => 42); int retVal = AsyncResultWrapper.End <int>(asyncResult); // Assert Assert.Equal(42, retVal); Assert.True(asyncResult.IsCompleted); Assert.True(asyncResult.CompletedSynchronously); }
protected virtual IAsyncResult BeginExecuteCore(AsyncCallback callback, object state) { // If code in this method needs to be updated, please also check the ExecuteCore() method // of Controller to see if that code also must be updated. PossiblyLoadTempData(); try { string actionName = RouteData.GetRequiredString("action"); IActionInvoker invoker = ActionInvoker; IAsyncActionInvoker asyncInvoker = invoker as IAsyncActionInvoker; if (asyncInvoker != null) { // asynchronous invocation // Ensure delegates continue to use the C# Compiler static delegate caching optimization. BeginInvokeDelegate <ExecuteCoreState> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, ExecuteCoreState innerState) { return(innerState.AsyncInvoker.BeginInvokeAction(innerState.Controller.ControllerContext, innerState.ActionName, asyncCallback, asyncState)); }; EndInvokeVoidDelegate <ExecuteCoreState> endDelegate = delegate(IAsyncResult asyncResult, ExecuteCoreState innerState) { if (!innerState.AsyncInvoker.EndInvokeAction(asyncResult)) { innerState.Controller.HandleUnknownAction(innerState.ActionName); } }; ExecuteCoreState executeState = new ExecuteCoreState() { Controller = this, AsyncInvoker = asyncInvoker, ActionName = actionName }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, executeState, _executeCoreTag)); } else { // synchronous invocation Action action = () => { if (!invoker.InvokeAction(ControllerContext, actionName)) { HandleUnknownAction(actionName); } }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _executeCoreTag)); } } catch { PossiblySaveTempData(); throw; } }
public void BeginSynchronous_Action() { // Arrange bool actionCalled = false; // Act IAsyncResult asyncResult = AsyncResultWrapper.BeginSynchronous(null, null, delegate { actionCalled = true; }); AsyncResultWrapper.End(asyncResult); // Assert Assert.True(actionCalled); Assert.True(asyncResult.IsCompleted); Assert.True(asyncResult.CompletedSynchronously); }
protected virtual IAsyncResult BeginExecuteCore(AsyncCallback callback, object state) { // If code in this method needs to be updated, please also check the ExecuteCore() method // of Controller to see if that code also must be updated. PossiblyLoadTempData(); try { string actionName = RouteData.GetRequiredString("action"); IActionInvoker invoker = ActionInvoker; IAsyncActionInvoker asyncInvoker = invoker as IAsyncActionInvoker; if (asyncInvoker != null) { // asynchronous invocation BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) { return(asyncInvoker.BeginInvokeAction(ControllerContext, actionName, asyncCallback, asyncState)); }; EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult) { if (!asyncInvoker.EndInvokeAction(asyncResult)) { HandleUnknownAction(actionName); } }; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _executeCoreTag)); } else { // synchronous invocation Action action = () => { if (!invoker.InvokeAction(ControllerContext, actionName)) { HandleUnknownAction(actionName); } }; return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _executeCoreTag)); } } catch { PossiblySaveTempData(); throw; } }
public void BeginSynchronous_Func() { object expectedReturn = new object(); object expectedState = new object(); object expectedCallbackState = new object(); bool funcCalled = false; bool asyncCalledbackCalled = false; // Act IAsyncResult asyncResult = AsyncResultWrapper.BeginSynchronous( callback: (innerIAsyncResult) => { asyncCalledbackCalled = true; Assert.NotNull(innerIAsyncResult); Assert.Same(expectedCallbackState, innerIAsyncResult.AsyncState); Assert.True(innerIAsyncResult.IsCompleted); Assert.True(innerIAsyncResult.CompletedSynchronously); }, callbackState: expectedCallbackState, func: (innerIAsyncResult, innerState) => { funcCalled = true; Assert.NotNull(innerIAsyncResult); Assert.Same(expectedCallbackState, innerIAsyncResult.AsyncState); Assert.Same(expectedState, innerState); Assert.True(innerIAsyncResult.IsCompleted); Assert.True(innerIAsyncResult.CompletedSynchronously); return(expectedReturn); }, funcState: expectedState, tag: null ); object retVal = AsyncResultWrapper.End <object>(asyncResult); // Assert Assert.Same(expectedReturn, retVal); Assert.True(asyncResult.IsCompleted); Assert.True(asyncResult.CompletedSynchronously); Assert.True(funcCalled); Assert.True(asyncCalledbackCalled); }
protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state) { BeginInvokeDelegate delegate4 = null; EndInvokeDelegate delegate5 = null; Action action2 = null; IHttpHandler httpHandler = GetHttpHandler(httpContext); IHttpAsyncHandler httpAsyncHandler = httpHandler as IHttpAsyncHandler; if (httpAsyncHandler != null) { if (delegate4 == null) { delegate4 = (asyncCallback, asyncState) => httpAsyncHandler.BeginProcessRequest(HttpContext.Current, asyncCallback, asyncState); } BeginInvokeDelegate beginDelegate = delegate4; if (delegate5 == null) { delegate5 = delegate(IAsyncResult asyncResult) { httpAsyncHandler.EndProcessRequest(asyncResult); }; } EndInvokeDelegate endDelegate = delegate5; return(AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _processRequestTag)); } if (action2 == null) { action2 = delegate { httpHandler.ProcessRequest(HttpContext.Current); } } ; Action action = action2; 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 )); } }