C# ContextCallback类代码示例

        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
         }
     }
 }