Когда несколько ожиданий имеют смысл?

Question

У меня есть некоторые недоразумения с C# async/ждут механизм. Есть ли существенная разница между

private async void Init() 
{ 
    await Task.Run(() => Do1()); 
    await Task.Run(() => Do2()); 
} 

и

private async void Init() 
{ 
    await Task.Run(() => 
    { 
     Do1(); 
     Do2(); 
    }); 
} 

Единственное различие, которое я вижу: в первом образце Do1 и dO2 будут работать в разных потоках, а во втором образце - в том же нить. Но опять же, какова реальная польза от него, и когда я должен предпочесть первый подход к второму и наоборот?

EDIT: Второй случай

В чем разница между

private async void Init() 
{ 
    await Task.Run(() => Do1()); 
    Do3(); 
} 

и

private async void Init() 
{ 
    await Task.Run(() => 
    { 
     Do1(); 
     Do3(); 
    }); 
} 

Answer 1

Разница заключается в том:

Первый пример:

• Вы очереди Do1 на Threadpool нити и асинхронно ждать его завершения, затем выполните то же самое с Do2. Они могут работать на разных потоках.
• Вы ставите Do1 и Do2, чтобы выполнить синхронно один за другим в одном потоке потока потока.

Второй пример:

• Очередь Do1 на ThreadPool и асинхронно ждать его завершения, а затем вызвать Do3 синхронно.
• Это точно так же, как и вторая часть первого примера.

Обратите внимание, что когда вы await, вы асинхронно ждать завершения операции, поэтому, если метод не закончит он не будет выполнять следующую строку кода.

Я предполагаю, что вы спрашиваете себя, предпочтительнее ли другой, и как в большинстве случаев это зависит. Если вы используете внутри консольного приложения, и вы собираетесь асинхронно ждать завершения Do1, то передайте оба метода тому же вызову Task.Run. Если вы планируете делать это в том месте, где важна синхронизация, например, в графическом приложении, тогда в поток пользовательского интерфейса должна быть активирована любая операция, которая должна взаимодействовать с элементами управления пользовательским интерфейсом.

Другой вариант, который чаще встречается, заключается в том, что у вас есть две операции, которые независимы друг от друга, и вы хотите начать их вместе и дождаться завершения. Это где вы будете использовать Task.WhenAll:

var firstDo = Task.Run(() => Do1()); 
var secondDo = Task.Run(() => Do2()); 
await Task.WhenAll(firstDo, secondDo); 

примечание стороны:

Не использовать async void в асинхронных методов без возвращаемого значения, то есть то, что async Task для. Первый предназначен только для обеспечения совместимости с обработчиками событий, где я предполагаю, что это не так.

Answer 2

• если Do1() и Do2() независимы друг от друга, вы должны запустить их в отдельности. Это еще более важно, если они являются длительными/блокирующими процессами
• , с другой стороны, если они связаны друг с другом, и первый выполняет некоторые операции, которые требуются другим, тогда лучше запустить их в одном потоке для уменьшения накладных расходов. В конце концов, вы заранее знаете, что они должны выполняться последовательно