public void Start()
{
#if !DISABLE_SECURITY
// propagate informations from the original thread to the new thread
#if NET_2_0
if (!ExecutionContext.IsFlowSuppressed())
{
ec_to_set = ExecutionContext.Capture();
}
#else
// before 2.0 this was only used for security (mostly CAS) so we
// do this only if the security manager is active
if (SecurityManager.SecurityEnabled)
{
ec_to_set = ExecutionContext.Capture();
}
#endif
if (CurrentThread._principal != null)
{
_principal = CurrentThread._principal;
}
#endif
// Thread_internal creates and starts the new thread,
#if NET_2_1 && !MONOTOUCH && !MICRO_LIB
if (Thread_internal((ThreadStart)StartSafe) == (IntPtr)0)
#else
if (Thread_internal(threadstart) == (IntPtr)0)
#endif
{ throw new SystemException("Thread creation failed."); }
}
public void Undo()
{
if (_thread == null)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseAFCMultiple"));
}
if (Thread.CurrentThread != _thread)
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseAFCOtherThread"));
}
// An async flow control cannot be undone when a different execution context is applied. The desktop framework
// mutates the execution context when its state changes, and only changes the instance when an execution context
// is applied (for instance, through ExecutionContext.Run). The framework prevents a suppressed-flow execution
// context from being applied by returning null from ExecutionContext.Capture, so the only type of execution
// context that can be applied is one whose flow is not suppressed. After suppressing flow and changing an async
// local's value, the desktop framework verifies that a different execution context has not been applied by
// checking the execution context instance against the one saved from when flow was suppressed. In .NET Core,
// since the execution context instance will change after changing the async local's value, it verifies that a
// different execution context has not been applied, by instead ensuring that the current execution context's
// flow is suppressed.
if (!ExecutionContext.IsFlowSuppressed())
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AsyncFlowCtrlCtxMismatch"));
}
Contract.EndContractBlock();
_thread = null;
ExecutionContext.RestoreFlow();
}
public static bool QueueUserWorkItem(WaitCallback callBack, object state)
{
if (Microsoft.ThreadPool.UseMicrosoftThreadPool)
{
return(Microsoft.ThreadPool.QueueUserWorkItem(callBack, state));
}
else
{
if (callBack == null)
{
throw new ArgumentNullException("callBack");
}
if (callBack.IsTransparentProxy())
{
IAsyncResult ar = callBack.BeginInvoke(state, null, null);
if (ar == null)
{
return(false);
}
}
else
{
AsyncResult ares = new AsyncResult(callBack, state, !ExecutionContext.IsFlowSuppressed());
pool_queue(ares);
}
return(true);
}
}
public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state)
{
// no stack propagation here (that's why it's unsafe and requires extra security permissions)
if (!callBack.IsTransparentProxy())
{
if (!callBack.HasSingleTarget)
{
throw new Exception("The delegate must have only one target");
}
AsyncResult ares = new AsyncResult(callBack, state, false);
pool_queue(ares);
return(true);
}
try {
if (!ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.SuppressFlow(); // on current thread only
}
IAsyncResult ar = callBack.BeginInvoke(state, null, null);
if (ar == null)
{
return(false);
}
} finally {
if (ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.RestoreFlow();
}
}
return(true);
}
internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, object state, bool compressStack, ref StackCrawlMark stackMark)
{
this._waitOrTimerCallback = waitOrTimerCallback;
this._state = state;
if (compressStack && !ExecutionContext.IsFlowSuppressed())
{
this._executionContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
}
}
internal QueueUserWorkItemCallback(WaitCallback waitCallback, object stateObj, bool compressStack, ref StackCrawlMark stackMark)
{
this.callback = waitCallback;
this.state = stateObj;
if (compressStack && !ExecutionContext.IsFlowSuppressed())
{
this.context = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
}
}
internal _TimerCallback(TimerCallback timerCallback, object state, ref StackCrawlMark stackMark)
{
this._timerCallback = timerCallback;
this._state = state;
if (!ExecutionContext.IsFlowSuppressed())
{
this._executionContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.OptimizeDefaultCase | ExecutionContext.CaptureOptions.IgnoreSyncCtx);
}
}
internal _TimerCallback(TimerCallback timerCallback, object state, ref StackCrawlMark stackMark)
{
this._timerCallback = timerCallback;
this._state = state;
if (!ExecutionContext.IsFlowSuppressed())
{
this._executionContext = ExecutionContext.Capture(ref stackMark);
ExecutionContext.ClearSyncContext(this._executionContext);
}
}
internal _ThreadPoolWaitCallback(WaitCallback waitCallback, object state, bool compressStack, ref StackCrawlMark stackMark)
{
this._waitCallback = waitCallback;
this._state = state;
if (compressStack && !ExecutionContext.IsFlowSuppressed())
{
this._executionContext = ExecutionContext.Capture(ref stackMark);
ExecutionContext.ClearSyncContext(this._executionContext);
}
}
internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, Object state, bool compressStack, ref StackCrawlMark stackMark)
{
_waitOrTimerCallback = waitOrTimerCallback;
_state = state;
if (compressStack && !ExecutionContext.IsFlowSuppressed())
{
// capture the exection context
_executionContext = ExecutionContext.Capture(ref stackMark);
ExecutionContext.ClearSyncContext(_executionContext);
}
}
public static AsyncFlowControl SuppressFlow()
{
if (ExecutionContext.IsFlowSuppressed())
{
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotSupressFlowMultipleTimes"));
}
AsyncFlowControl asyncFlowControl = new AsyncFlowControl();
asyncFlowControl.Setup();
return(asyncFlowControl);
}
public void Start()
{
// propagate informations from the original thread to the new thread
if (!ExecutionContext.IsFlowSuppressed())
{
ec_to_set = ExecutionContext.Capture();
}
Internal._serialized_principal = CurrentThread.Internal._serialized_principal;
// Thread_internal creates and starts the new thread,
if (Thread_internal((ThreadStart)StartInternal) == (IntPtr)0)
{
throw new SystemException("Thread creation failed.");
}
}
internal TimerQueueTimer(TimerCallback timerCallback, object state, uint dueTime, uint period, ref StackCrawlMark stackMark)
{
this.m_timerCallback = timerCallback;
this.m_state = state;
this.m_dueTime = uint.MaxValue;
this.m_period = uint.MaxValue;
if (!ExecutionContext.IsFlowSuppressed())
{
this.m_executionContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
}
if (dueTime != 4294967295U)
{
this.Change(dueTime, period);
}
}
public Barrier(int participantCount, Action <Barrier> postPhaseAction)
{
if ((participantCount < 0) || (participantCount > 0x7fff))
{
throw new ArgumentOutOfRangeException("participantCount", participantCount, SR.GetString("Barrier_ctor_ArgumentOutOfRange"));
}
this.m_currentTotalCount = participantCount;
this.m_postPhaseAction = postPhaseAction;
this.m_oddEvent = new ManualResetEventSlim(true);
this.m_evenEvent = new ManualResetEventSlim(false);
if ((postPhaseAction != null) && !ExecutionContext.IsFlowSuppressed())
{
this.m_ownerThreadContext = ExecutionContext.Capture();
}
this.m_actionCallerID = 0;
}
public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state)
{
// no stack propagation here (that's why it's unsafe and requires extra security permissions)
IAsyncResult ar = null;
try {
if (!ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.SuppressFlow(); // on current thread only
}
ar = callBack.BeginInvoke(state, null, null);
}
finally {
if (ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.RestoreFlow();
}
}
return(ar != null);
}
/// <summary>
/// Initializes a new instance of the <see cref="Barrier"/> class.
/// </summary>
/// <param name="participantCount">The number of participating threads.</param>
/// <param name="postPhaseAction">The <see cref="T:System.Action`1"/> to be executed after each
/// phase.</param>
/// <exception cref="T:System.ArgumentOutOfRangeException"> <paramref name="participantCount"/> is less than 0
/// or greater than <see cref="T:System.Int32.MaxValue"/>.</exception>
/// <remarks>
/// The <paramref name="postPhaseAction"/> delegate will be executed after
/// all participants have arrived at the barrier in one phase. The participants
/// will not be released to the next phase until the postPhaseAction delegate
/// has completed execution.
/// </remarks>
public Barrier(int participantCount, Action <Barrier> postPhaseAction)
{
// the count must be non negative value
if (participantCount < 0 || participantCount > Max_Participants)
{
throw new ArgumentOutOfRangeException("participantCount", participantCount, "The participantCount argument must be non-negative and less than or equal to 32767.");
}
Thread.VolatileWrite(ref _currentTotalCount, participantCount);
_postPhaseAction = postPhaseAction;
//Lazily initialize the events
_oddEvent = new ManualResetEventSlim(true);
_evenEvent = new ManualResetEventSlim(false);
// Capture the context if the post phase action is not null
if (postPhaseAction != null && !ExecutionContext.IsFlowSuppressed())
{
_ownerThreadContext = ExecutionContext.Capture();
}
_actionCallerId = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="Barrier"/> class.
/// </summary>
/// <param name="participantCount">The number of participating threads.</param>
/// <param name="postPhaseAction">The <see cref="T:System.Action`1"/> to be executed after each
/// phase.</param>
/// <exception cref="T:System.ArgumentOutOfRangeException"> <paramref name="participantCount"/> is less than 0
/// or greater than <see cref="T:System.Int32.MaxValue"/>.</exception>
/// <remarks>
/// The <paramref name="postPhaseAction"/> delegate will be executed after
/// all participants have arrived at the barrier in one phase. The participants
/// will not be released to the next phase until the postPhaseAction delegate
/// has completed execution.
/// </remarks>
public Barrier(int participantCount, Action <Barrier> postPhaseAction)
{
// the count must be non negative value
if (participantCount < 0 || participantCount > MAX_PARTICIPANTS)
{
throw new ArgumentOutOfRangeException("participantCount", participantCount, "Barrier_ctor_ArgumentOutOfRange");
}
m_currentTotalCount = (int)participantCount;
m_postPhaseAction = postPhaseAction;
//Lazily initialize the events
m_oddEvent = new ManualResetEventSlim(true);
m_evenEvent = new ManualResetEventSlim(false);
// Capture the context if the post phase action is not null
if (postPhaseAction != null && !ExecutionContext.IsFlowSuppressed())
{
m_ownerThreadContext = ExecutionContext.Capture();
}
m_actionCallerID = 0;
}
public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state)
{
if (Microsoft.ThreadPool.UseMicrosoftThreadPool)
{
return(Microsoft.ThreadPool.UnsafeQueueUserWorkItem(callBack, state));
}
else
{
if (callBack == null)
{
throw new ArgumentNullException("callBack");
}
// no stack propagation here (that's why it's unsafe and requires extra security permissions)
if (!callBack.IsTransparentProxy())
{
AsyncResult ares = new AsyncResult(callBack, state, false);
pool_queue(ares);
return(true);
}
try {
if (!ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.SuppressFlow(); // on current thread only
}
IAsyncResult ar = callBack.BeginInvoke(state, null, null);
if (ar == null)
{
return(false);
}
} finally {
if (ExecutionContext.IsFlowSuppressed())
{
ExecutionContext.RestoreFlow();
}
}
return(true);
}
}
internal TimerQueueTimer(TimerCallback timerCallback, object state, uint dueTime, uint period, ref StackCrawlMark stackMark)
{
m_timerCallback = timerCallback;
m_state = state;
m_dueTime = Timeout.UnsignedInfinite;
m_period = Timeout.UnsignedInfinite;
if (!ExecutionContext.IsFlowSuppressed())
{
m_executionContext = ExecutionContext.Capture(
ref stackMark,
ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
}
//
// After the following statement, the timer may fire. No more manipulation of timer state outside of
// the lock is permitted beyond this point!
//
if (dueTime != Timeout.UnsignedInfinite)
{
Change(dueTime, period);
}
}
