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);
}
}));
}
public void SyncWithAction()
{
// Arrange
bool actionWasCalled = false;
bool sendWasCalled = false;
Mock <SynchronizationContext> mockSyncContext = new Mock <SynchronizationContext>();
mockSyncContext
.Setup(sc => sc.Send(It.IsAny <SendOrPostCallback>(), null))
.Callback(
delegate(SendOrPostCallback d, object state)
{
sendWasCalled = true;
d(state);
}
);
// Act
SynchronizationContextUtil.Sync(
mockSyncContext.Object,
() =>
{
actionWasCalled = true;
}
);
// Assert
Assert.True(actionWasCalled);
Assert.True(sendWasCalled);
}
public void SyncWithActionCapturesException()
{
// Arrange
InvalidOperationException exception = new InvalidOperationException("Some exception text.");
Mock <SynchronizationContext> mockSyncContext = new Mock <SynchronizationContext>();
mockSyncContext
.Setup(sc => sc.Send(It.IsAny <SendOrPostCallback>(), null))
.Callback(
delegate(SendOrPostCallback d, object state)
{
try
{
d(state);
}
catch
{
// swallow exceptions, just like AspNetSynchronizationContext
}
});
// Act & assert
SynchronousOperationException thrownException = Assert.Throws <SynchronousOperationException>(
delegate { SynchronizationContextUtil.Sync(mockSyncContext.Object, () => { throw exception; }); },
@"An operation that crossed a synchronization context failed. See the inner exception for more information.");
Assert.Equal(exception, thrownException.InnerException);
}
internal SyncEventMethodInfo(MethodInfo methodInfo, bool isArgless)
{
if (IsAsyncVoidMethod(methodInfo))
{
SynchronizationContextUtil.ValidateModeForPageAsyncVoidMethods();
}
MethodInfo = methodInfo;
IsArgless = isArgless;
}
// TAP
internal PageAsyncTask(Func <CancellationToken, Task> handler, SynchronizationContextMode currentMode)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
// The legacy PageAsyncTaskManager doesn't support TAP methods
SynchronizationContextUtil.ValidateMode(currentMode, requiredMode: SynchronizationContextMode.Normal, specificErrorMessage: SR.SynchronizationContextUtil_TaskReturningPageAsyncMethodsNotCompatible);
TaskHandler = handler;
}
public void SyncWithFunc()
{
// Arrange
bool sendWasCalled = false;
Mock <SynchronizationContext> mockSyncContext = new Mock <SynchronizationContext>();
mockSyncContext
.Expect(sc => sc.Send(It.IsAny <SendOrPostCallback>(), null))
.Callback(
delegate(SendOrPostCallback d, object state) {
sendWasCalled = true;
d(state);
});
// Act
int retVal = SynchronizationContextUtil.Sync(mockSyncContext.Object, () => 42);
// Assert
Assert.AreEqual(42, retVal);
Assert.IsTrue(sendWasCalled);
}
// APM
internal PageAsyncTask(BeginEventHandler beginHandler, EndEventHandler endHandler, EndEventHandler timeoutHandler, Object state, bool executeInParallel, SynchronizationContextMode currentMode)
{
if (beginHandler == null)
{
throw new ArgumentNullException("beginHandler");
}
if (endHandler == null)
{
throw new ArgumentNullException("endHandler");
}
// Only the legacy PageAsyncTaskManager supports timing out APM methods or executing them in parallel
if (timeoutHandler != null || executeInParallel)
{
SynchronizationContextUtil.ValidateMode(currentMode, requiredMode: SynchronizationContextMode.Legacy, specificErrorMessage: SR.SynchronizationContextUtil_PageAsyncTaskTimeoutHandlerParallelNotCompatible);
}
BeginHandler = beginHandler;
EndHandler = endHandler;
TimeoutHandler = timeoutHandler;
State = state;
ExecuteInParallel = executeInParallel;
}
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
));
}
}
