public struct AsyncFlowControl: IDisposable

    {

        private bool useEC;

        private ExecutionContext _ec;

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

        private SecurityContext _sc;

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

        private Thread _thread;

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

        [SecurityCritical]

        internal void Setup(SecurityContextDisableFlow flags)

        {

            useEC = false;

            Thread currentThread = Thread.CurrentThread;

            _sc = currentThread.GetMutableExecutionContext().SecurityContext;

            _sc._disableFlow = flags;

            _thread = currentThread;

        }

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

        [SecurityCritical]

        internal void Setup()

        {

            useEC = true;

            Thread currentThread = Thread.CurrentThread;

            _ec = currentThread.GetMutableExecutionContext();

            _ec.isFlowSuppressed = true;

            _thread = currentThread;

        }

        public void Dispose()

        {

            Undo();

        }

        [SecuritySafeCritical]

        public void Undo()

        {

            if (_thread == null)

            {

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseAFCMultiple"));

            }

            if (_thread != Thread.CurrentThread)

            {

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotUseAFCOtherThread"));

            }

            if (useEC)

            {

                if (Thread.CurrentThread.GetMutableExecutionContext() != _ec)

                {

                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AsyncFlowCtrlCtxMismatch"));

                }

                ExecutionContext.RestoreFlow();

            }

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            else

            {

                if (!Thread.CurrentThread.GetExecutionContextReader().SecurityContext.IsSame(_sc))

                {

                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AsyncFlowCtrlCtxMismatch"));

                }

                SecurityContext.RestoreFlow();

            }

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            _thread = null;

        }

    }

public sealed class ExecutionContext : IDisposable, ISerializable

    {

#if FEATURE_CAS_POLICY

        private HostExecutionContext _hostExecutionContext;

#endif // FEATURE_CAS_POLICY

        private SynchronizationContext _syncContext;

        private SynchronizationContext _syncContextNoFlow;

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

        private SecurityContext     _securityContext;

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

#if FEATURE_REMOTING

        private LogicalCallContext  _logicalCallContext;

        private IllogicalCallContext _illogicalCallContext;  // this call context follows the physical thread

#endif // #if FEATURE_REMOTING

        private Flags _flags;

        private Dictionary<IAsyncLocal, object> _localValues;

        private List<IAsyncLocal> _localChangeNotifications;

        public static AsyncFlowControl SuppressFlow()

        {

            if (IsFlowSuppressed())

            {

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotSupressFlowMultipleTimes"));

            }

            Contract.EndContractBlock();

            AsyncFlowControl afc = new AsyncFlowControl();

            afc.Setup();

            return afc;

        }

        public static void RestoreFlow()

        {

            ExecutionContext ec = Thread.CurrentThread.GetMutableExecutionContext();

            if (!ec.isFlowSuppressed)

            {

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotRestoreUnsupressedFlow"));

            }

            ec.isFlowSuppressed = false;

        }

        public static bool IsFlowSuppressed()

        {

            return Thread.CurrentThread.GetExecutionContextReader().IsFlowSuppressed;

        }

        public static ExecutionContext Capture()

        {

            // set up a stack mark for finding the caller

            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;

            return ExecutionContext.Capture(ref stackMark, CaptureOptions.None);

        }

         static internal ExecutionContext Capture(ref StackCrawlMark stackMark, CaptureOptions options)

        {

            ExecutionContext.Reader ecCurrent = Thread.CurrentThread.GetExecutionContextReader();

            // check to see if Flow is suppressed

            if (ecCurrent.IsFlowSuppressed)

                return null;

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            // capture the security context

            SecurityContext secCtxNew = SecurityContext.Capture(ecCurrent, ref stackMark);

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

#if FEATURE_CAS_POLICY

             // capture the host execution context

            HostExecutionContext hostCtxNew = HostExecutionContextManager.CaptureHostExecutionContext();

#endif // FEATURE_CAS_POLICY

            SynchronizationContext syncCtxNew = null;

#if FEATURE_REMOTING

            LogicalCallContext logCtxNew = null;

#endif

            if (!ecCurrent.IsNull)

            {

                // capture the sync context

                if ( == (options & CaptureOptions.IgnoreSyncCtx))

                    syncCtxNew = (ecCurrent.SynchronizationContext == null) ? null : ecCurrent.SynchronizationContext.CreateCopy();

#if FEATURE_REMOTING

                // copy over the Logical Call Context

                if (ecCurrent.LogicalCallContext.HasInfo)

                    logCtxNew = ecCurrent.LogicalCallContext.Clone();

#endif // #if FEATURE_REMOTING

            }

            Dictionary<IAsyncLocal, object> localValues = null;

            List<IAsyncLocal> localChangeNotifications = null;

            if (!ecCurrent.IsNull)

            {

                localValues = ecCurrent.DangerousGetRawExecutionContext()._localValues;

                localChangeNotifications = ecCurrent.DangerousGetRawExecutionContext()._localChangeNotifications;

            }

            //

            // If we didn't get anything but defaults, and we're allowed to return the

            // dummy default EC, don't bother allocating a new context.

            //

            if ( != (options & CaptureOptions.OptimizeDefaultCase) &&

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

                secCtxNew == null &&

#endif

#if FEATURE_CAS_POLICY

                hostCtxNew == null &&

#endif // FEATURE_CAS_POLICY

                syncCtxNew == null &&

#if FEATURE_REMOTING

                (logCtxNew == null || !logCtxNew.HasInfo) &&

#endif // #if FEATURE_REMOTING

                localValues == null &&

                localChangeNotifications == null

                )

            {

                return s_dummyDefaultEC;

            }

            //

            // Allocate the new context, and fill it in.

            //

            ExecutionContext ecNew = new ExecutionContext();

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            ecNew.SecurityContext = secCtxNew;

            if (ecNew.SecurityContext != null)

                ecNew.SecurityContext.ExecutionContext = ecNew;

#endif

#if FEATURE_CAS_POLICY

            ecNew._hostExecutionContext = hostCtxNew;

#endif // FEATURE_CAS_POLICY

            ecNew._syncContext = syncCtxNew;

#if FEATURE_REMOTING

            ecNew.LogicalCallContext = logCtxNew;

#endif // #if FEATURE_REMOTING

            ecNew._localValues = localValues;

            ecNew._localChangeNotifications = localChangeNotifications;

            ecNew.isNewCapture = true;

            return ecNew;

        }

        public static void Run(ExecutionContext executionContext, ContextCallback callback, Object state)

        {

            if (executionContext == null)

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullContext"));

            if (!executionContext.isNewCapture)

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));

            Run(executionContext, callback, state, false);

       }

      internal static void Run(ExecutionContext executionContext, ContextCallback callback, Object state, bool preserveSyncCtx)

        {

            RunInternal(executionContext, callback, state, preserveSyncCtx);

        }

       internal static void RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, bool preserveSyncCtx)

        {

            Contract.Assert(executionContext != null);

            if (executionContext.IsPreAllocatedDefault)

            {

                Contract.Assert(executionContext.IsDefaultFTContext(preserveSyncCtx));

            }

            else

            {

                Contract.Assert(executionContext.isNewCapture);

                executionContext.isNewCapture = false;

            }

            Thread currentThread = Thread.CurrentThread;

            ExecutionContextSwitcher ecsw = default(ExecutionContextSwitcher);

            RuntimeHelpers.PrepareConstrainedRegions();

            try

            {

                ExecutionContext.Reader ec = currentThread.GetExecutionContextReader();

                if ( (ec.IsNull || ec.IsDefaultFTContext(preserveSyncCtx)) &&

    #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

                    SecurityContext.CurrentlyInDefaultFTSecurityContext(ec) &&

    #endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

                    executionContext.IsDefaultFTContext(preserveSyncCtx) &&

                    ec.HasSameLocalValues(executionContext)

                    )

                {

                    // Neither context is interesting, so we don't need to set the context.

                    // We do need to reset any changes made by the user's callback,

                    // so here we establish a "copy-on-write scope".  Any changes will

                    // result in a copy of the context being made, preserving the original

                    // context.

                    EstablishCopyOnWriteScope(currentThread, true, ref ecsw);

                }

                else

                {

                    if (executionContext.IsPreAllocatedDefault)

                        executionContext = new ExecutionContext();

                    ecsw = SetExecutionContext(executionContext, preserveSyncCtx);

                }

                //

                // Call the user's callback

                //

                callback(state);

            }

            finally

            {

                ecsw.Undo();

            }

        }

        public ExecutionContext CreateCopy()

        {

            if (!isNewCapture)

            {

                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_CannotCopyUsedContext"));

            }

            ExecutionContext ec = new ExecutionContext();

            ec.isNewCapture = true;

            ec._syncContext = _syncContext == null ? null : _syncContext.CreateCopy();

            ec._localValues = _localValues;

            ec._localChangeNotifications = _localChangeNotifications;

#if FEATURE_CAS_POLICY

            // capture the host execution context

            ec._hostExecutionContext = _hostExecutionContext == null ? null : _hostExecutionContext.CreateCopy();

#endif // FEATURE_CAS_POLICY

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            if (_securityContext != null)

            {

                ec._securityContext = _securityContext.CreateCopy();

                ec._securityContext.ExecutionContext = ec;

            }

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

#if FEATURE_REMOTING

            if (this._logicalCallContext != null)

                ec.LogicalCallContext = (LogicalCallContext)this.LogicalCallContext.Clone();

            Contract.Assert(this._illogicalCallContext == null);

#endif // #if FEATURE_REMOTING

            return ec;

        }

      internal  static ExecutionContextSwitcher SetExecutionContext(ExecutionContext executionContext, bool preserveSyncCtx)

        {

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

            Contract.Assert(executionContext != null);

            Contract.Assert(executionContext != s_dummyDefaultEC);

            // Set up the switcher object to return;

            ExecutionContextSwitcher ecsw = new ExecutionContextSwitcher();

            Thread currentThread = Thread.CurrentThread;

            ExecutionContext.Reader outerEC = currentThread.GetExecutionContextReader();

            ecsw.thread = currentThread;

            ecsw.outerEC = outerEC;

            ecsw.outerECBelongsToScope = currentThread.ExecutionContextBelongsToCurrentScope;

            if (preserveSyncCtx)

                executionContext.SynchronizationContext = outerEC.SynchronizationContext;

            executionContext.SynchronizationContextNoFlow = outerEC.SynchronizationContextNoFlow;

            currentThread.SetExecutionContext(executionContext, belongsToCurrentScope: true);

            RuntimeHelpers.PrepareConstrainedRegions();

            try

            {

                OnAsyncLocalContextChanged(outerEC.DangerousGetRawExecutionContext(), executionContext);

#if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

                //set the security context

                SecurityContext sc = executionContext.SecurityContext;

                if (sc != null)

                {

                    // non-null SC: needs to be set

                    SecurityContext.Reader prevSeC = outerEC.SecurityContext;

                    ecsw.scsw = SecurityContext.SetSecurityContext(sc, prevSeC, false, ref stackMark);

                }

                else if (!SecurityContext.CurrentlyInDefaultFTSecurityContext(ecsw.outerEC))

                {

                    // null incoming SC, but we're currently not in FT: use static FTSC to set

                    SecurityContext.Reader prevSeC = outerEC.SecurityContext;

                    ecsw.scsw = SecurityContext.SetSecurityContext(SecurityContext.FullTrustSecurityContext, prevSeC, false, ref stackMark);

                }

#endif // #if FEATURE_IMPERSONATION || FEATURE_COMPRESSEDSTACK

#if FEATURE_CAS_POLICY

                // set the Host Context

                HostExecutionContext hostContext = executionContext.HostExecutionContext;

                if (hostContext != null)

                {

                    ecsw.hecsw = HostExecutionContextManager.SetHostExecutionContextInternal(hostContext);

                }

#endif // FEATURE_CAS_POLICY

            }

            catch

            {

                ecsw.UndoNoThrow();

                throw;

            }

            return ecsw;

        }

    }