internal static void FilterExceptionThroughCausalities(ITask task, Exception exception)
{
try
{
CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities();
if (CausalityThreadContext.IsEmpty(currentThreadCausalities))
{
if (task != null)
{
DispatcherQueue taskQueue = task.TaskQueue;
if (!taskQueue.RaiseUnhandledException(exception))
{
Dispatcher dispatcher = taskQueue.Dispatcher;
if (dispatcher != null)
{
dispatcher.RaiseUnhandledException(exception);
}
}
}
}
else
{
currentThreadCausalities.PostException(exception);
}
}
catch (Exception exception2)
{
Dispatcher.LogError(Resource1.ExceptionDuringCausalityHandling, exception2);
}
}
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);
}
internal static CausalityThreadContext CloneCausalitiesFromCurrentThread()
{
if (!Dispatcher._causalitiesActive)
{
return(null);
}
CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities();
if (CausalityThreadContext.IsEmpty(currentThreadCausalities))
{
return(null);
}
return(currentThreadCausalities.Clone());
}
internal void AddCausality(ICausality causality)
{
if (CausalityThreadContext.IsEmpty(this))
{
ActiveCausality = causality;
return;
}
if (CausalityTable == null)
{
CausalityTable = new Dictionary <Guid, ICausality>();
}
if (ActiveCausality == null)
{
if (Stacks != null)
{
if (CausalityTable.ContainsKey(causality.Guid))
{
return;
}
CausalityTable.Add(causality.Guid, causality);
foreach (CausalityStack current in Stacks)
{
current.Add(causality);
}
}
return;
}
if (causality.Guid == ActiveCausality.Guid)
{
return;
}
CausalityTable.Add(ActiveCausality.Guid, ActiveCausality);
CausalityTable.Add(causality.Guid, causality);
Stacks = new List <CausalityStack>();
CausalityStack causalityStack = new CausalityStack();
causalityStack.Add(ActiveCausality);
causalityStack.Add(causality);
ActiveCausality = null;
Stacks.Add(causalityStack);
}
private static bool RemoveCausality(string name, ICausality causality)
{
CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities();
return(!CausalityThreadContext.IsEmpty(currentThreadCausalities) && currentThreadCausalities.RemoveCausality(name, causality));
}
