C# async ждет странное поведение

Question

Я новичок в C#, и пока я пытаюсь понять async/await feautures. Таким образом, я создал небольшую песочницу приложения:

namespace sandbox 
{ 
public class Test 
{ 
    public async Task<string> GetItemsAsync() 
    { 
     var a = await Task1(); 
     var b = await Task2(); 
     var c = await Task3(); 

     return a + b + c; 
    } 

    public string GetItems() 
    { 
     return _T1() + _T2() + _T3(); 
    } 

    private readonly int cycles = 100000000; 

    private async Task<string> Task1() 
    { 
     return await Task.Factory.StartNew(_T1); 
    } 

    private async Task<string> Task2() 
    { 
     return await Task.Factory.StartNew(_T2); 
    } 

    private async Task<string> Task3() 
    { 
     return await Task.Factory.StartNew(_T3); 
    } 

    // long running operation 
    private string _T1() 
    { 
     for (int i = 0; i < cycles; i++) ; 
     for (int i = 0; i < cycles; i++) ; 
     return "One"; 
    } 

    // long running operation 
    private string _T2() 
    { 
     for (int i = 0; i < cycles; i++) ; 
     for (int i = 0; i < cycles; i++) ; 
     return "Two"; 
    } 

    // long running operation 
    private string _T3() 
    { 
     for (int i = 0; i < cycles; i++) ; 
     for (int i = 0; i < cycles; i++) ; 
     return "Three"; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     var t = new Test(); 

     Console.WriteLine("Async"); 
     Stopwatch sw = new Stopwatch(); 
     sw.Start(); 
     var result = t.GetItemsAsync(); 
     Console.WriteLine(result.Result); 
     sw.Stop(); 
     Console.WriteLine(sw.ElapsedMilliseconds); 

     Console.WriteLine("Sync"); 
     sw.Restart(); 
     var strResult = t.GetItems(); 
     Console.WriteLine(strResult); 
     sw.Stop(); 
     Console.WriteLine(sw.ElapsedMilliseconds); 

     Console.ReadLine(); 
    } 
} 
} 

Но результат странно:

Async 
OneTwoThree 
1754 
Sync 
OneTwoThree 
1506 

метод Асинхронного работает дольше, чем аналогичные синхронизации один. Для меня это похоже, что методы async работают синхронно, но я не могу понять, почему.

Answer 1

Из-за этого:

var a = await Task1(); 
var b = await Task2(); 
var c = await Task3(); 

Прежде чем начать Task2 вы ждали Task1, чтобы закончить. Таким образом, вы не запускаете их параллельно, вы запускаете их последовательно.

Если вы хотите, чтобы начать все 3 задачи, а затем ждать их завершения вы должны изменить этот метод следующим образом:

public async Task<string> GetItemsAsync() 
{ 
    var t1 = Task1(); 
    var t2 = Task2(); 
    var t3 = Task3(); 

    var a = await t1; 
    var b = await t2; 
    var c = await t3; 

    return a + b + c; 
} 

или только последнюю часть:

return (await t1) + (await t2) + (await t3); 

Дополнительно этот код является антипаттерн:

private async Task<string> Task3() 
{ 
    return await Task.Factory.StartNew(_T3); 
} 

Вам не нужно async/await здесь becaus e вы не делаете больше работы в этом методе после того, как ваша подзадача возвращает.

Вместо просто переписать этот метод (и его братьев и сестер) к этому:

private Task<string> Task3() 
{ 
    return Task.Factory.StartNew(_T3); 
} 

Answer 2

Я подозреваю, что намерение состояло в том, чтобы сделать все три задачи сделать работу параллельно. Это один из вариантов того, как это можно сделать:

public async Task<string> GetItemsAsync() 
{ 
    var a = Task1(); 
    var b = Task2(); 
    var c = Task3(); 

    return string.Concat(await Task.WhenAll(a, b, c)); 
}