private static IteratorContext ExecuteTaskHelper(ITask currentTask)
{
if (currentTask.LinkedIterator != null)
{
IteratorContext iteratorContext = (IteratorContext)currentTask.LinkedIterator;
if (CausalityThreadContext.IsEmpty(iteratorContext._causalities))
{
Dispatcher.ClearCausalities();
}
else
{
Dispatcher.SetCurrentThreadCausalities(iteratorContext._causalities.Clone());
}
}
else
{
Dispatcher.TransferCausalitiesFromTaskToCurrentThread(currentTask);
}
if (Debugger.IsAttached)
{
CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities();
if (!CausalityThreadContext.IsEmpty(currentThreadCausalities) && CausalityThreadContext.RequiresDebugBreak(currentThreadCausalities))
{
Debugger.Break();
}
}
IEnumerator <ITask> enumerator = currentTask.Execute();
if (enumerator != null)
{
return(new IteratorContext(enumerator, Dispatcher.GetCurrentThreadCausalities()));
}
return(null);
}
public static void AddCausality(ICausality causality)
{
Dispatcher._causalitiesActive = true;
CausalityThreadContext causalityThreadContext = Dispatcher.GetCurrentThreadCausalities();
if (CausalityThreadContext.IsEmpty(causalityThreadContext))
{
causalityThreadContext = new CausalityThreadContext(causality, null);
Dispatcher.SetCurrentThreadCausalities(causalityThreadContext);
return;
}
causalityThreadContext.AddCausality(causality);
}
private void SignalTimer(DispatcherQueue.TimerContext tc)
{
try
{
Dispatcher.SetCurrentThreadCausalities(tc.CausalityContext);
tc.TimerPort.Post(DateTime.Now);
Dispatcher.ClearCausalities();
}
catch (Exception exception)
{
Dispatcher.LogError("DispatcherQueue:TimerHandler", exception);
}
}
private static void HandleException(ITask currentTask, Exception e)
{
Dispatcher.LogError(Resource1.HandleExceptionLog, e);
Dispatcher.FilterExceptionThroughCausalities(currentTask, e);
Dispatcher.SetCurrentThreadCausalities(null);
if (currentTask != null && currentTask.ArbiterCleanupHandler != null)
{
try
{
currentTask.ArbiterCleanupHandler();
}
catch (Exception exception)
{
Dispatcher.LogError(Resource1.ExceptionDuringArbiterCleanup, exception);
}
}
}
public static void ExecuteInCurrentThreadContext(object t)
{
ITask task = (ITask)t;
try
{
TaskExecutionWorker.ExecuteTask(ref task, task.TaskQueue, false);
Dispatcher.SetCurrentThreadCausalities(null);
}
catch (Exception ex)
{
if (TaskExecutionWorker.IsCriticalException(ex))
{
throw;
}
TaskExecutionWorker.HandleException(task, ex);
}
}
private void ClrSystemTimerHandler(object state)
{
DispatcherQueue.ClrSystemTimerContext clrSystemTimerContext = (DispatcherQueue.ClrSystemTimerContext)state;
try
{
lock (_clrSystemTimerTable)
{
_clrSystemTimerTable.Remove(clrSystemTimerContext.Id);
}
clrSystemTimerContext.Timer.Dispose();
Dispatcher.SetCurrentThreadCausalities(clrSystemTimerContext.CausalityContext);
clrSystemTimerContext.TimerPort.Post(DateTime.Now);
}
catch (Exception exception)
{
Dispatcher.LogError("DispatcherQueue:TimerHandler", exception);
}
}
private static void ExecuteTask(ref ITask currentTask, DispatcherQueue p, bool bypassExecute)
{
Handler arbiterCleanupHandler = currentTask.ArbiterCleanupHandler;
IteratorContext iteratorContext;
if (bypassExecute)
{
iteratorContext = null;
}
else
{
iteratorContext = TaskExecutionWorker.ExecuteTaskHelper(currentTask);
}
if (iteratorContext == null)
{
iteratorContext = (IteratorContext)currentTask.LinkedIterator;
}
if (iteratorContext != null)
{
Dispatcher.SetCurrentThreadCausalities(iteratorContext._causalities);
TaskExecutionWorker.MoveIterator(ref currentTask, iteratorContext, ref arbiterCleanupHandler);
if (currentTask != null)
{
currentTask.LinkedIterator = iteratorContext;
currentTask.TaskQueue = p;
iteratorContext = TaskExecutionWorker.ExecuteTaskHelper(currentTask);
if (iteratorContext != null)
{
TaskExecutionWorker.NestIterator(currentTask);
}
}
}
if (arbiterCleanupHandler != null)
{
if (currentTask != null)
{
currentTask.ArbiterCleanupHandler = null;
}
arbiterCleanupHandler();
}
}
internal static void TransferCausalitiesFromTaskToCurrentThread(ITask currentTask)
{
if (!Dispatcher._causalitiesActive)
{
return;
}
CausalityThreadContext causalityThreadContext = null;
for (int i = 0; i < currentTask.PortElementCount; i++)
{
IPortElement portElement = currentTask[i];
if (portElement != null && portElement.CausalityContext != null)
{
CausalityThreadContext context = (CausalityThreadContext)portElement.CausalityContext;
if (causalityThreadContext == null)
{
causalityThreadContext = new CausalityThreadContext(null, null);
}
causalityThreadContext.MergeWith(context);
}
}
Dispatcher.SetCurrentThreadCausalities(causalityThreadContext);
}
public override IEnumerator <ITask> Execute()
{
Dispatcher.SetCurrentThreadCausalities(_causalityContext);
_handler();
return(null);
}
public static void ClearCausalities()
{
Dispatcher.SetCurrentThreadCausalities(null);
}
