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);
}
internal static void SetCurrentThreadCausalities(CausalityThreadContext context)
{
if (!Dispatcher._causalitiesActive)
{
return;
}
try
{
Dispatcher._causalityTable[Thread.CurrentThread.ManagedThreadId] = context;
}
catch (Exception)
{
if (!Dispatcher._causalityTable.ContainsKey(Thread.CurrentThread.ManagedThreadId))
{
try
{
Dispatcher.AddThread(Thread.CurrentThread);
Dispatcher._causalityTable[Thread.CurrentThread.ManagedThreadId] = context;
}
catch
{
}
}
}
}
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);
}
}
internal static bool RequiresDebugBreak(CausalityThreadContext context)
{
if (context == null)
{
return(false);
}
if (context.ActiveCausality != null && context.ActiveCausality is Causality)
{
return(((Causality)context.ActiveCausality).BreakOnReceive);
}
if (context.Stacks != null)
{
foreach (CausalityStack current in context.Stacks)
{
foreach (ICausality current2 in current)
{
Causality causality = current2 as Causality;
if (causality != null && causality.BreakOnReceive)
{
return(true);
}
}
}
return(false);
}
return(false);
}
public ClrSystemTimerContext(Port <DateTime> timerPort, CausalityThreadContext causalityContext)
{
CausalityContext = causalityContext;
lock (typeof(DispatcherQueue.ClrSystemTimerContext))
{
DispatcherQueue._timerContextIdentifier += 1L;
Id = DispatcherQueue._timerContextIdentifier;
}
TimerPort = timerPort;
}
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 CausalityThreadContext Clone()
{
CausalityThreadContext causalityThreadContext = new CausalityThreadContext(ActiveCausality, null);
if (ActiveCausality != null)
{
return(causalityThreadContext);
}
causalityThreadContext.Stacks = new List <CausalityStack>();
foreach (CausalityStack current in Stacks)
{
CausalityStack causalityStack = new CausalityStack();
causalityStack.AddRange(current);
causalityThreadContext.Stacks.Add(causalityStack);
}
return(causalityThreadContext);
}
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);
}
protected virtual Timer EnqueueTimerUsingClrSystemTimers(TimeSpan timeSpan, Port <DateTime> timerPort)
{
CausalityThreadContext causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread();
if (timeSpan.TotalMilliseconds <= 5.0 && timeSpan.Milliseconds >= 0)
{
timerPort.Post(DateTime.Now);
return(null);
}
timeSpan = TimeSpan.FromSeconds(timeSpan.TotalSeconds * _timescale);
DispatcherQueue.ClrSystemTimerContext clrSystemTimerContext = new DispatcherQueue.ClrSystemTimerContext(timerPort, causalityContext);
Timer timer = new Timer(new TimerCallback(ClrSystemTimerHandler), clrSystemTimerContext, -1, -1);
clrSystemTimerContext.Timer = timer;
lock (_clrSystemTimerTable)
{
_clrSystemTimerTable.Add(clrSystemTimerContext.Id, timer);
}
timer.Change(timeSpan, TimeSpan.FromMilliseconds(-1.0));
return(timer);
}
public virtual void EnqueueTimer(TimeSpan timeSpan, Port <DateTime> timerPort)
{
if (_dispatcher == null || (_dispatcher.Options & DispatcherOptions.UseHighAccuracyTimerLogic) == DispatcherOptions.None)
{
EnqueueTimerUsingClrSystemTimers(timeSpan, timerPort);
return;
}
CausalityThreadContext causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread();
timeSpan = TimeSpan.FromSeconds(timeSpan.TotalSeconds * _timescale);
DateTime dateTime = DateTime.UtcNow + timeSpan;
DispatcherQueue.TimerContext item = new DispatcherQueue.TimerContext(timerPort, causalityContext, dateTime);
bool flag = false;
lock (_timerTable)
{
if (dateTime < _nextTimerExpiration)
{
_nextTimerExpiration = dateTime;
flag = true;
}
if (_timerTable.ContainsKey(dateTime.Ticks))
{
_timerTable[dateTime.Ticks].Add(item);
}
else
{
List <DispatcherQueue.TimerContext> list = new List <DispatcherQueue.TimerContext>(1);
list.Add(item);
_timerTable[dateTime.Ticks] = list;
}
}
if (flag)
{
Enqueue(new Task(delegate
{
}));
}
}
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 IterativeTask(IteratorHandler handler)
{
_Handler = handler;
_causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread();
}
public TimerContext(Port <DateTime> timerPort, CausalityThreadContext causalityContext, DateTime expiration)
{
CausalityContext = causalityContext;
TimerPort = timerPort;
Expiration = expiration;
}
private static bool RemoveCausality(string name, ICausality causality)
{
CausalityThreadContext currentThreadCausalities = Dispatcher.GetCurrentThreadCausalities();
return(!CausalityThreadContext.IsEmpty(currentThreadCausalities) && currentThreadCausalities.RemoveCausality(name, causality));
}
internal void MergeWith(CausalityThreadContext context)
{
if (Stacks == null && ActiveCausality == null)
{
if (context.ActiveCausality != null)
{
AddCausality(context.ActiveCausality);
return;
}
foreach (CausalityStack current in context.Stacks)
{
AddCausalityStack(current);
}
return;
}
else
{
if (Stacks == null)
{
Stacks = new List <CausalityStack>(1);
}
if (CausalityTable == null)
{
CausalityTable = new Dictionary <Guid, ICausality>();
}
if (Stacks.Count == 0 && context.ActiveCausality != null)
{
if (ActiveCausality.Guid == context.ActiveCausality.Guid)
{
return;
}
CausalityTable[ActiveCausality.Guid] = ActiveCausality;
CausalityTable[context.ActiveCausality.Guid] = context.ActiveCausality;
((List <CausalityStack>)Stacks).Add(new CausalityStack());
((List <CausalityStack>)Stacks)[0].Add(ActiveCausality);
((List <CausalityStack>)Stacks).Add(new CausalityStack());
((List <CausalityStack>)Stacks)[1].Add(context.ActiveCausality);
ActiveCausality = null;
return;
}
else
{
if (ActiveCausality != null && context.Stacks != null)
{
((List <CausalityStack>)Stacks).Add(new CausalityStack());
((List <CausalityStack>)Stacks)[0].Add(ActiveCausality);
CausalityTable[ActiveCausality.Guid] = ActiveCausality;
foreach (CausalityStack current2 in context.Stacks)
{
AddCausalityStack(current2);
}
ActiveCausality = null;
Normalize();
return;
}
if (Stacks.Count > 0 && context.Stacks != null)
{
foreach (CausalityStack current3 in context.Stacks)
{
AddCausalityStack(current3);
}
}
return;
}
}
}
public static bool IsEmpty(CausalityThreadContext context)
{
return(context == null || (context.ActiveCausality == null && context.Stacks == null));
}
public Task(Handler handler)
{
_handler = handler;
_causalityContext = Dispatcher.CloneCausalitiesFromCurrentThread();
}
public IteratorContext(IEnumerator <ITask> iterator, CausalityThreadContext causalities)
{
_iterator = iterator;
_causalities = causalities;
}
