public static void Run(CompressedStack compressedStack, ContextCallback callback, object state)
        {
            if (compressedStack == null)
            {
                throw new ArgumentNullException(nameof(compressedStack));
            }

            // The original code was not checking for a null callback and would throw NullReferenceException
            callback(state);
        }

 private static ContextCallback GetPostActionCallback()
 {
     var callback = _postActionCallback;
     if (callback == null)
     {
         // lazily initialize SecurityCritical delegate
         _postActionCallback = callback = PostAction;
     }
     return callback;
 }

 internal static void PartialTrustInvoke(ContextCallback callback, object state)
 {
     if (NeedPartialTrustInvoke)
     {
         SecurityContext.Run(aspNetSecurityContext.CreateCopy(), callback, state);
     }
     else
     {
         callback(state);
     }
 }

 internal void ExecuteCallback()
 {
     if (TargetExecutionContext != null)
     {
         var callback = s_executionContextCallback;
         if (callback == null)
             s_executionContextCallback = callback = new ContextCallback(CancellationCallbackInfo.ExecutionContextCallback);
         ExecutionContext.Run(this.TargetExecutionContext, callback, this);
     }
     else
         ExecutionContextCallback(this);
 }

 /// <summary>
 /// Runs a method in a specified execution context on the current thread.
 /// </summary>
 public static void Run(ExecutionContext context, ContextCallback callback, object state)
 {
     var syncContext = SynchronizationContext.Current;
     try
     {
         SynchronizationContext.SetSynchronizationContext(context.m_synchronizationContext);
         callback(state);
     }
     finally
     {
         SynchronizationContext.SetSynchronizationContext(syncContext);
     }
 }

 /// <summary>
 /// The Enqueue method is invoked to add a callback action
 /// to the sequencer's queue of operations.
 /// </summary>
 /// <param name="callback">
 /// The callback that is to be invoked.
 /// </param>
 /// <param name="state">
 /// The state information to be passed to the callback
 /// method when it is executed.
 /// </param>
 public void Enqueue(ContextCallback callback, object state)
 {
     SequencedTask task = new SequencedTask(callback, state, ExecutionContext.Capture());
     lock (_taskQueue)
     {
         _taskQueue.Enqueue(task);
         if (_pending == false)
         {
             _pending = true;
             ThreadPool.UnsafeQueueUserWorkItem(Execute, null);
         }
     }
 }

 internal void ExecuteCallback()
 {
     if (this.TargetExecutionContext != null)
     {
         ContextCallback contextCallback = CancellationCallbackInfo.s_executionContextCallback;
         if (contextCallback == null)
         {
             contextCallback = (CancellationCallbackInfo.s_executionContextCallback = new ContextCallback(CancellationCallbackInfo.ExecutionContextCallback));
         }
         ExecutionContext.Run(this.TargetExecutionContext, contextCallback, this);
         return;
     }
     CancellationCallbackInfo.ExecutionContextCallback(this);
 }

        public static void Run(ExecutionContext executionContext, ContextCallback callback, Object state)
        {
            ExecutionContextSwitcher ecsw = default(ExecutionContextSwitcher);
            try
            {
                EstablishCopyOnWriteScope(ref ecsw);

                ExecutionContext.Restore(executionContext);
                callback(state);
            }
            catch
            {
                // Note: we have a "catch" rather than a "finally" because we want
                // to stop the first pass of EH here.  That way we can restore the previous
                // context before any of our callers' EH filters run.  That means we need to 
                // end the scope separately in the non-exceptional case below.
                ecsw.Undo();
                throw;
            }
            ecsw.Undo();
        }

 /// <summary>
 /// Queues a work item for processing on the managed thread pool
 /// </summary>
 /// <param name="callback">A WaitCallback representing the method to execute.</param>
 /// <param name="ctx">Alternate execution context in which to run the thread.</param>
 /// <returns>Reference to queued thread</returns>
 /// <remarks>
 /// This differs from the normal thread pool QueueUserWorkItem function in that it does
 /// not return a success value determing if item was queued, but rather a reference to
 /// to the managed thread that was actually placed on the queue.
 /// </remarks>
 public static ManagedThread QueueUserWorkItem(ContextCallback callback, ExecutionContext ctx)
 {
     return QueueUserWorkItem(callback, null, ctx);
 }

		public static void Run (ExecutionContext executionContext, ContextCallback callback, object state)
		{
			if (executionContext == null) {
				throw new InvalidOperationException (Locale.GetText (
					"Null ExecutionContext"));
			}

			// FIXME: supporting more than one context should be done with executionContextSwitcher
			// and will requires a rewrite of this method
			var callContextCallBack = new ContextCallback (new Action<object> ((ostate) => {
				var originalCallContext = CallContext.CreateLogicalCallContext (true);
				try {
					CallContext.SetCurrentCallContext (executionContext.LogicalCallContext);
					callback (ostate);
				} finally {
					CallContext.SetCurrentCallContext (originalCallContext);
				}
			}));
			SecurityContext.Run (executionContext.SecurityContext, callContextCallBack, state);
		}

 /// <summary>
 /// Initializes a new instance of the ManagedThread class, specifying a delegate that allows an object to be passed to the thread when the thread is started
 /// and allowing the user to specify an alternate execution context for the thread.
 /// </summary>
 public ManagedThread(ContextCallback callback, ExecutionContext ctx)
     : this(ThreadType.StandardThread, callback, null, ctx)
 {
     m_thread = new Thread(HandleItem);
 }

 public CallbackEntry(int number, int range, ContextCallback callback)
     : base(number, range)
 {
     m_Callback = callback;
 }

 internal ExecutionContextRunData(ExecutionContext executionContext, ContextCallback cb, Object state)
 {
     this.ec = executionContext;
     this.callBack = cb;
     this.state = state;
     ecsw = new ExecutionContextSwitcher();
 }

        public static void Run(ExecutionContext executionContext, ContextCallback callback, Object state)
        {
            if (executionContext == null)
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullContext"));

            Thread currentThread = Thread.CurrentThread;
            ExecutionContextSwitcher ecsw = default(ExecutionContextSwitcher);
            try
            {
                EstablishCopyOnWriteScope(currentThread, ref ecsw);
                ExecutionContext.Restore(currentThread, executionContext);
                callback(state);
            }
            catch
            {
                // Note: we have a "catch" rather than a "finally" because we want
                // to stop the first pass of EH here.  That way we can restore the previous
                // context before any of our callers' EH filters run.  That means we need to 
                // end the scope separately in the non-exceptional case below.
                ecsw.Undo(currentThread);
                throw;
            }
            ecsw.Undo(currentThread);
        }

 internal void CallCallback()
 {
     // call directly if EC flow is suppressed
     if (m_executionContext == null)
     {
         m_timerCallback(m_state);
     }
     else
     {
         using (ExecutionContext executionContext = 
             m_executionContext.IsPreAllocatedDefault ? m_executionContext : m_executionContext.CreateCopy())
         {
             ContextCallback callback = s_callCallbackInContext;
             if (callback == null)
                 s_callCallbackInContext = callback = new ContextCallback(CallCallbackInContext);
             
             ExecutionContext.Run(
                 executionContext,
                 callback,
                 this,  // state
                 true); // ignoreSyncCtx
         }
     }
 }

        /// <summary>
        /// Finish the phase by invoking the post phase action, and setting the event, this must be called by the 
        /// last arrival thread
        /// </summary>
        /// <param name="observedSense">The current phase sense</param>
        private void FinishPhase(bool observedSense)
        {
            // Execute the PHA in try/finally block to reset the variables back in case of it threw an exception
            if (_postPhaseAction != null)
            {
                try
                {
                    // Capture the caller thread ID to check if the Add/RemoveParticipant(s) is called from the PHA
                    _actionCallerID = Environment.CurrentManagedThreadId;
                    if (_ownerThreadContext != null)
                    {
                        var currentContext = _ownerThreadContext;

                        ContextCallback handler = s_invokePostPhaseAction;
                        if (handler == null)
                        {
                            s_invokePostPhaseAction = handler = InvokePostPhaseAction;
                        }
                        ExecutionContext.Run(_ownerThreadContext, handler, this);
                    }
                    else
                    {
                        _postPhaseAction(this);
                    }

                    _exception = null; // reset the exception if it was set previously
                }
                catch (Exception ex)
                {
                    _exception = ex;
                }
                finally
                {
                    _actionCallerID = 0;
                    SetResetEvents(observedSense);
                    if (_exception != null)
                        throw new BarrierPostPhaseException(_exception);
                }
            }
            else
            {
                SetResetEvents(observedSense);
            }
        }

        internal unsafe static void CompleteWithCallback(uint errorCode, uint bytesWritten, Win32ThreadPoolNativeOverlapped* overlapped)
        {
            OverlappedData data = overlapped->Data;

            Debug.Assert(!data._completed);
            data._completed = true;

            ContextCallback callback = s_executionContextCallback;
            if (callback == null)
                s_executionContextCallback = callback = OnExecutionContextCallback;

            // Get an args object from the per-thread cache.
            ExecutionContextCallbackArgs args = t_executionContextCallbackArgs;
            if (args == null)
                args = new ExecutionContextCallbackArgs();

            t_executionContextCallbackArgs = null;

            args._errorCode = errorCode;
            args._bytesWritten = bytesWritten;
            args._overlapped = overlapped;
            args._data = data;

            ExecutionContext.Run(data._executionContext, callback, args);
        }

        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"));
            }
            
            executionContext.isNewCapture = false;
            
            ExecutionContext ec = Thread.CurrentThread.GetExecutionContextNoCreate();
            if ( (ec == null || ec.IsDefaultFTContext()) && SecurityContext.CurrentlyInDefaultFTSecurityContext(ec)
                && executionContext.IsDefaultFTContext())
            {
                callback(state);
            }
            else
            {
                RunInternal(executionContext, callback, state);
            }
        }

        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
        public static void Run(SecurityContext securityContext, ContextCallback callback, Object state)
        {
            if (securityContext == null )
            {
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullContext"));
            }
            Contract.EndContractBlock();

            StackCrawlMark stackMark = StackCrawlMark.LookForMe;

            if (!securityContext.isNewCapture)
            {
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NotNewCaptureContext"));
            }

            securityContext.isNewCapture = false;
#if !MOBILE
            ExecutionContext.Reader ec = Thread.CurrentThread.GetExecutionContextReader();
            
            // Optimization: do the callback directly if both the current and target contexts are equal to the
            // default full-trust security context
            if ( SecurityContext.CurrentlyInDefaultFTSecurityContext(ec)
                && securityContext.IsDefaultFTSecurityContext())
            {
                callback(state);
                
                if (GetCurrentWI(Thread.CurrentThread.GetExecutionContextReader()) != null) 
                {
                    // If we enter here it means the callback did an impersonation
                    // that we need to revert.
                    // We don't need to revert any other security state since it is stack-based 
                    // and automatically goes away when the callback returns.
                    WindowsIdentity.SafeRevertToSelf(ref stackMark);
                    // Ensure we have reverted to the state we entered in.
                    Contract.Assert(GetCurrentWI(Thread.CurrentThread.GetExecutionContextReader()) == null);
                }
            }
            else
#endif
            {
                RunInternal(securityContext, callback, state);
            }

        }

 internal SecurityContextRunData(SecurityContext securityContext, ContextCallback cb, Object state)
 {
     this.sc = securityContext;
     this.callBack = cb;
     this.state = state;
     this.scsw = new SecurityContextSwitcher();
 }