Come funziona .NET ExecutionContext?

Question

Sto cercando di scoprire come il ExecutionContext funzioni effettivamente nella versione 4.0 e successive di .NET Framework. La documentazione afferma che il principio gestito, la sincronizzazione, le impostazioni internazionali e il contesto utente passano tutti al nuovo thread quando si utilizza Thread.Start e la maggior parte delle operazioni del pool di thread. Ma non riesco a vederlo funzionare in pratica.

Ecco una semplice applicazione console che mette alla prova se il contesto di sincronizzazione e il principio del flusso gestito quando si inizia un nuovo thread ...

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

Il risultato è ...

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

Così il il contesto di sincronizzazione non scorre mai e il principio gestito scorre sempre anche quando specifichi che non dovrebbe. Fondamentalmente la documentazione è completamente sbagliata. Quindi c'è una descrizione di ciò che ExecutionContext fa in realtà e perché è utile?

Answer 1

Questa è una documentazione ingannevole. Non riesco a rispondere alla più ampia spinta della tua domanda, ma posso dirti perché il flusso SynchronizationContext non scorre.

Se si guarda alla fonte di Thread.Start, alla fine chiama verso il basso per:

[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 che passa in modo esplicito ExecutionContext.CaptureOptions.IgnoreSyncCtx per impostazione predefinita. Passa anche CallContext.Principal indipendentemente da ExecutionContext.SuppressFlow(). Quindi, spiega perché stai vedendo quello che stai vedendo, ma non quando potrebbe essere utile o perché i documenti sono completamente sbagliati!