public void RegisterTask_AsynchronousCompletion_SwallowsExceptionsThrownByEndDelegate()
{
// Arrange
SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
AsyncManager asyncManager = new AsyncManager(syncContext);
bool endDelegateWasCalled = false;
ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */);
Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
{
MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */);
ThreadPool.QueueUserWorkItem(_ =>
{
callback(asyncResult);
waitHandle.Set();
});
return asyncResult;
};
Action<IAsyncResult> endDelegate = delegate
{
endDelegateWasCalled = true;
throw new Exception("This is a sample exception.");
};
// Act
asyncManager.RegisterTask(beginDelegate, endDelegate);
waitHandle.WaitOne();
// Assert
Assert.True(endDelegateWasCalled);
Assert.Equal(0, asyncManager.OutstandingOperations.Count);
}
private static void ProcessMessage(Message msg, AsyncManager asyncMgr)
{
switch (msg.Type)
{
case MessageTypes.Results:
ProcessResults(msg, asyncMgr);
break;
}
asyncMgr.OutstandingOperations.Decrement();
}
public static void Connect(Guid connectionId, AsyncManager asyncManager)
{
Complete(connectionId, null);
lock (((IDictionary)Subscribers).SyncRoot)
lock (((IDictionary)Connections).SyncRoot)
{
var timer = new Timer(TimeSpan.FromSeconds(10).TotalMilliseconds) { AutoReset = false };
timer.Elapsed += (sender, args) => Complete(connectionId, null);
Connections.Add(connectionId, new Connection(connectionId, asyncManager, timer));
asyncManager.OutstandingOperations.Increment();
timer.Start();
}
}
public void RegisterTask_ResetsOutstandingOperationCountIfBeginMethodThrows()
{
// Arrange
SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
AsyncManager asyncManager = new AsyncManager(syncContext);
Func<AsyncCallback, IAsyncResult> beginDelegate = cb => { throw new InvalidOperationException("BeginDelegate throws."); };
Action<IAsyncResult> endDelegate = ar => { Assert.True(false, "This should never be called."); };
// Act & assert
Assert.Throws<InvalidOperationException>(
delegate { asyncManager.RegisterTask(beginDelegate, endDelegate); }, "BeginDelegate throws.");
Assert.Equal(0, asyncManager.OutstandingOperations.Count);
}
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));
}
public void RegisterTask_SynchronousCompletion()
{
// Arrange
SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
AsyncManager asyncManager = new AsyncManager(syncContext);
bool endDelegateWasCalled = false;
Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
{
Assert.Equal(1, asyncManager.OutstandingOperations.Count);
MockAsyncResult asyncResult = new MockAsyncResult(true /* completedSynchronously */);
callback(asyncResult);
return asyncResult;
};
Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; };
// Act
asyncManager.RegisterTask(beginDelegate, endDelegate);
// Assert
Assert.True(endDelegateWasCalled);
Assert.False(syncContext.SendWasCalled);
Assert.Equal(0, asyncManager.OutstandingOperations.Count);
}
public Connection(Guid id, AsyncManager manager, Timer timer)
{
Id = id;
Manager = manager;
Timer = timer;
}
private static void ProcessResults(Message msg, AsyncManager asyncMgr)
{
var results = LogQueryResults.DeserializeLog(msg.Data);
asyncMgr.Parameters["details"] = results.LogIDs;
}
public MovieInfoAsync(AsyncManager manager)
{
_manager = manager;
}