Task.Start, Task.RunSynchronously und Synchronisationskontext

Question

ich manuell eine Aufgabe konstruieren:

var task = new Task(() => 
    Debug.WriteLine("Task")); 

es dann manuell starten:

task.Start(TaskScheduler.FromCurrentSynchronizationContext()); 

Ich erwarte, dass es über SynchronizationContext.Post geplant werden, sein.

Aber wenn es auf diese Weise beginnen:

task.RunSynchronously(TaskScheduler.FromCurrentSynchronizationContext()); 

Wird es über SynchronizationContext.Send oder direkt ausgeführt werden von der Lambda-Aufgabe aufrufen?

Answer 1

Wird es über SynchronizationContext.Send oder direkt über ausgeführt, wobei das Lambda der Task aufgerufen wird?

Hier ist was los ist. Zuerst versucht Task.RunSynchronously die Aufgabe auszuführen, indem scheduler.TryExecuteTaskInline Aufruf. Im Fall mit SynchronizationContextTaskScheduler, es ist dies:

protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) 
{ 
    return ((SynchronizationContext.Current == this.m_synchronizationContext) && base.TryExecuteTask(task)); 
} 

Also, wenn auf dem gleichen Synchronisations Zusammenhang wird die Aufgabe Lambda direkt in base.TryExecuteTask ausgeführt werden.

Andernfalls stellt die Task den Taskplaner mit Task.RunSynchronously in den Wartezustand und blockiert die Task WaitHandle mit der blockierenden Warte.

SynchronizationContext.Send tut nicht in jedem Fall beteiligt werden.

Was ist das interessant ist. AFAIK, in WPF kann es auf dem Haupt UI Thread mehr DispatcherSynchronizationContext Kontexte sein, ein pro Fenster der obersten Ebene. Daher kann RunSynchronously theoretisch zu einem Deadlock führen. Ich werde das überprüfen.

Aktualisiert, der Deadlock in WPF ist real. Hier ist, wie man Repro:

public partial class MainWindow : Window 
{ 
    public MainWindow() 
    { 
     InitializeComponent(); 

     this.Loaded += MainWindow_Loaded; 
    } 

    void MainWindow_Loaded(object sMainWindow, RoutedEventArgs eMainWindow) 
    { 
     var task = new Task(() => 
      Debug.WriteLine("Task")); 

     var scheduler = TaskScheduler.FromCurrentSynchronizationContext(); 

     var window1 = new Window(); 
     window1.Loaded += (sWindow1, eWindow1) => 
     { 
      // Deadlock in WPF 
      task.RunSynchronously(scheduler); 
      Debug.WriteLine("Done!"); 
     }; 
     window1.Show(); 
    } 
}