¿Cómo funciona .NET ExecutionContext en realidad?

Question

Estoy tratando de descubrir cómo funciona realmente el ExecutionContext en la versión 4.0 y posteriores de .NET Framework. La documentación dice que el principio administrado, la sincronización, la configuración regional y el contexto del usuario fluyen al nuevo hilo cuando se usa Thread.Start y la mayoría de las operaciones del grupo de subprocesos. Pero no puedo ver que esto funcione en la práctica.

Aquí es una simple aplicación de consola que pone a prueba si el contexto de sincronización y gestionado flujo principio al iniciar un nuevo hilo ...

static void Main(string[] args) 
    { 
     SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); 
     Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("One"), null); 

     Thread t1 = new Thread(new ThreadStart(ThreadRun)); 
     t1.Start(); 
     t1.Join(); 

     SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); 
     Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("Two"), null); 

     AsyncFlowControl aFC = ExecutionContext.SuppressFlow(); 
     Thread t2 = new Thread(new ThreadStart(ThreadRun)); 
     t2.Start(); 
     t2.Join(); 
     aFC.Undo(); 

     Console.Read(); 
    } 

    static void ThreadRun() 
    { 
     Console.WriteLine("ThreadRun Id={0} Context={1} Principle={2}", 
      Thread.CurrentThread.ManagedThreadId, 
      (SynchronizationContext.Current != null), 
      Thread.CurrentPrincipal.Identity.Name); 
    } 

El resultado es ...

ThreadRun Id=11 Context=False Principle=One 
    ThreadRun Id=12 Context=False Principle=Two 

Así que la el contexto de sincronización nunca fluye y el principio administrado siempre fluye incluso cuando usted especifica que no debería fluir. Básicamente, la documentación es completamente incorrecta. Entonces, ¿hay una descripción de lo que ExecutionContext hace en realidad y por qué es útil?

Answer 1

Esa es una documentación bastante engañosa. No puedo responder el empuje más amplio de su pregunta, pero puedo decirle por qué SynchronizationContext no fluye.

Si nos fijamos en la fuente de Thread.Start, con el tiempo a llamadas a través de:

[SecuritySafeCritical] 
    private void Start(ref StackCrawlMark stackMark) 
    { 
     this.StartupSetApartmentStateInternal(); 
     if (this.m_Delegate != null) 
     ((ThreadHelper) this.m_Delegate.Target).SetExecutionContextHelper(ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx)); 
     this.StartInternal(CallContext.Principal, ref stackMark); 
    } 

Nota que pasa explícitamente ExecutionContext.CaptureOptions.IgnoreSyncCtx por defecto. También pasa CallContext.Principal independientemente de ExecutionContext.SuppressFlow(). Por lo tanto, explica por qué está viendo lo que está viendo, pero no cuando podría ser útil o por qué los documentos están totalmente equivocados.