.net асинхронное ненормальное поведение

Question

У меня ненормальное поведение в WPF MainWindow ctor. Я использую асинхронный метод для выполнения большой задачи, но эта задача с именем «DoAsync» не завершена! Я нашел обходной путь, но я не понял, почему код не :(Вот два вызова и результаты:?

/// <summary> 
/// Interaction logic for MainWindow.xaml 
/// </summary> 
public partial class MainWindow : Window 
{ 
    static void WriteToOutput(string message, int increment = 0) 
    { 
     var nw = DateTime.Now; 
     var msg = string.Format("{0}.{1:d3} - thread {2:d1}[0x{3:x4}] |\t{4}{5}", 
            nw.ToString("hh:mm:ss"), 
            nw.Millisecond, 
            System.Threading.Thread.CurrentThread.ManagedThreadId, 
            AppDomain.GetCurrentThreadId(), 
            new string(' ', 4 * increment), 
            message 
           ); 

     System.Diagnostics.Debug.WriteLine(msg); 
    } 

    public async Task DoAsync() 
    { 
     WriteToOutput("DoAsync: begin", 2); 
     await Task.Delay(1);     // enforces asynchronism 
     WriteToOutput("DoAsync: job begin", 3); 
     System.Threading.Thread.Sleep(5000); // simulates some job ;) 
     WriteToOutput("DoAsync: job end", 3); 
     WriteToOutput("DoAsync: end", 2); 
    } 

    private void NormalBehavior() 
    { 
     WriteToOutput("NormalBehavior: begin", 0); 

     Task.Run(async() => 
     { 
      WriteToOutput("NormalBehavior_DoAsync: begin", 1); 
      await DoAsync(); 
      WriteToOutput("NormalBehavior_DoAsync: end", 1); 
     }); 

     WriteToOutput("NormalBehavior: sleeping", 0); 
     System.Threading.Thread.Sleep(10000);  // to see what happens 
     WriteToOutput("NormalBehavior: terminated", 0); 
    } 

    /// <summary> 
    /// Seems the simplest solution, but it fails :(Why ? 
    /// </summary> 
    private void AbnormalBehavior() 
    { 
     WriteToOutput("AbnormalBehavior: begin", 0); 

     WriteToOutput("AbnormalBehavior_DoAsync: begin", 1); 
     var tsk = DoAsync(); 
     WriteToOutput("AbnormalBehavior_DoAsync: end", 1); 

     WriteToOutput("AbnormalBehavior: sleeping", 0); 
     System.Threading.Thread.Sleep(10000);  // to see what happens 
     WriteToOutput("AbnormalBehavior: terminated", 0); 
    } 

    public MainWindow() 
    { 
     NormalBehavior(); 
     // Output: 
     // 05:18:00.833 - thread 8[0x3818] | NormalBehavior: begin 
     // 05:18:00.842 - thread 8[0x3818] | NormalBehavior: sleeping 
     // 05:18:00.846 - thread 9[0x2274] |  NormalBehavior_DoAsync: begin 
     // 05:18:00.848 - thread 9[0x2274] |   DoAsync: begin 
     // 05:18:00.853 - thread 10[0x0778] |    DoAsync: job begin 
     // 05:18:05.855 - thread 10[0x0778] |    DoAsync: job end 
     // 05:18:05.856 - thread 10[0x0778] |   DoAsync: end 
     // 05:18:05.856 - thread 10[0x0778] |  NormalBehavior_DoAsync: end 
     // 05:18:10.843 - thread 8[0x3818] | NormalBehavior: terminated 
     //_________________________________________________________________ 

     AbnormalBehavior(); 
     // Output: 
     // 05:18:10.845 - thread 8[0x3818] | AbnormalBehavior: begin 
     // 05:18:10.846 - thread 8[0x3818] |  AbnormalBehavior_DoAsync: begin 
     // 05:18:10.847 - thread 8[0x3818] |   DoAsync: begin 
     // 05:18:10.849 - thread 8[0x3818] |  AbnormalBehavior_DoAsync: end 
     // 05:18:10.850 - thread 8[0x3818] | AbnormalBehavior: sleeping 
     // 05:18:20.853 - thread 8[0x3818] | AbnormalBehavior: terminated 
     //_________________________________________________________________ 

     InitializeComponent(); 
    } 
} 

Никто уже нашли эту проблему или есть объяснение

Answer 1

Если вы смочите больше, я надеюсь, вы увидите DoWork «s„задание начать“и другие сообщения в окне отладки

Это ожидаемое поведение для async/await в частности, await будет фиксировать текущий„контекст“. -., которые в «ненормальным» случаем является контекст пользовательского интерфейса - и он возобновится на этом континууме доб. Я объясняю mechanics of async/await более подробно в своем блоге.

Другое примечание этим кодом состоит в том, что Thread.Sleep блокирует текущий поток. В частности, когда Thread.Sleep работает в потоке пользовательского интерфейса, этот поток блокируется и не может выполнять другой код.

Task.Run выполнит указанный код в потоке пула потоков, где нет контекста пользовательского интерфейса, и любой await в этом случае возобновится в потоке пула потоков.

Таким образом, при первом примере («рабочий») DoAsync работает по потоку пула потоков и блокирует поток пула потоков в течение 5 секунд. Тем временем NormalBehavior блокирует поток пользовательского интерфейса в течение 10 секунд.

Со вторым («неудачным») примером, AbnormalBehavior запускает DoAsync в потоке пользовательского интерфейса. Как только DoAsync попадает в его await, AbnormalBehavior продолжает работать и блокирует поток пользовательского интерфейса в течение 10 секунд. Только тогда DoAsync может возобновить работу в потоке пользовательского интерфейса и заблокировать его в течение 5 секунд.

Answer 2

Stephen вы правы, после последнего сна «AbnormalBehavior» я вижу «DoAsync: job begin» & «DoAsync: job end» все делается основной темой! Фактически это тот же поток (основной поток), который выполняет всю работу, и, как вы говорите, он не может выполнять «работу», пока он спит: | Даже тот же код работает, как я ожидал, в консольной программе! Как вы видите, в этом случае это другой поток (рабочий поток), который выполняет эту работу! Возможно, потому, что не нужно захватывать контекст !?

class Program 
{ 
    static DateTime _Start = new DateTime(0); 

    static void WriteToOutput(string message, int increment = 0, bool start = false) 
    { 
     var nw = DateTime.Now; 
     if (start) _Start = nw; 
     var spn = nw - _Start; 

     var msg = string.Format("{0,2:d}.{1:d3} - thread {2,2:d1}[0x{3:x4}] |\t{4}{5}", 
            (int)Math.Floor(spn.TotalSeconds), 
            spn.Milliseconds, 
            System.Threading.Thread.CurrentThread.ManagedThreadId, 
            AppDomain.GetCurrentThreadId(), 
            new string(' ', 4 * increment), 
            message 
           ); 

     if (start) msg = "\n" + msg; 
     //System.Diagnostics.Debug.WriteLine(msg); 
     Console.WriteLine(msg); 
    } 

    public static async Task DoAsync() 
    { 
     WriteToOutput("DoAsync: begin", 2); 
     await Task.Delay(1);     // enforces asynchronism 
     WriteToOutput("DoAsync: job begin", 3); 
     System.Threading.Thread.Sleep(5000); // simulates some job ;) 
     WriteToOutput("DoAsync: job end", 3); 
     WriteToOutput("DoAsync: end", 2); 
    } 

    /// <summary> 
    /// It works correctly but it uses more resources and run more slowly :o 
    /// </summary> 
    /// <returns></returns> 
    public static Task DoRescueAsync() 
    { 
     WriteToOutput("DoAsync: begin", 2); 
     return Task.Run(() => { 
      WriteToOutput("DoAsync: job begin", 3); 
      System.Threading.Thread.Sleep(5000); // simulates some job ;) 
      WriteToOutput("DoAsync: job end", 3); 
      WriteToOutput("DoAsync: end", 2); 
     }); 
    } 

    private static void NormalBehavior() 
    { 
     WriteToOutput("NormalBehavior: begin", 0, true); 

     Task.Run(async() => 
     { 
      WriteToOutput("NormalBehavior_DoAsync: begin", 1); 
      await DoAsync(); 
      WriteToOutput("NormalBehavior_DoAsync: end", 1); 
     }); 

     WriteToOutput("NormalBehavior: sleeping", 0); 
     System.Threading.Thread.Sleep(10000);  // to see what happens 
     WriteToOutput("NormalBehavior: terminated", 0); 
    } 

    /// <summary> 
    /// Seems the simplest solution, but it fails :(Why ? 
    /// </summary> 
    private static void AbnormalBehavior() 
    { 
     WriteToOutput("AbnormalBehavior: begin", 0, true); 

     WriteToOutput("AbnormalBehavior_DoAsync: begin", 1); 
     var tsk = DoAsync(); 
     WriteToOutput("AbnormalBehavior_DoAsync: end", 1); 

     WriteToOutput("AbnormalBehavior: sleeping", 0); 
     System.Threading.Thread.Sleep(10000);  // to see what happens 
     WriteToOutput("AbnormalBehavior: terminated", 0); 
    } 

    static void Main(string[] args) 
    { 
     NormalBehavior(); 
     // Output: 
     // 0.000 - thread 1[0x34cc] | NormalBehavior: begin 
     // 0.014 - thread 1[0x34cc] | NormalBehavior: sleeping 
     // 0.019 - thread 3[0x0bdc] |  NormalBehavior_DoAsync: begin 
     // 0.024 - thread 3[0x0bdc] |   DoAsync: begin 
     // 0.029 - thread 4[0x1568] |    DoAsync: job begin 
     // 5.045 - thread 4[0x1568] |    DoAsync: job end 
     // 5.050 - thread 4[0x1568] |   DoAsync: end 
     // 5.053 - thread 4[0x1568] |  NormalBehavior_DoAsync: end 
     // 10.018 - thread 1[0x34cc] | NormalBehavior: terminated 
     //_________________________________________________________________ 

     AbnormalBehavior();  // now CORRECT as expected ! 
     // Output: 
     // 0.000 - thread 1[0x34cc] | AbnormalBehavior: begin 
     // 0.008 - thread 1[0x34cc] |  AbnormalBehavior_DoAsync: begin 
     // 0.029 - thread 1[0x34cc] |   DoAsync: begin 
     // 0.037 - thread 1[0x34cc] |  AbnormalBehavior_DoAsync: end 
     // 0.043 - thread 1[0x34cc] | AbnormalBehavior: sleeping 
     // 0.047 - thread 3[0x0bdc] |    DoAsync: job begin 
     // 5.062 - thread 3[0x0bdc] |    DoAsync: job end 
     // 7.306 - thread 3[0x0bdc] |   DoAsync: end 
     //10.057 - thread 1[0x34cc] | AbnormalBehavior: terminated 
     //_________________________________________________________________ 

     Console.Write("\nHit a key to close console: "); Console.ReadKey(); 
    } 
}