Что происходит, когда вы ожидаете асинхронную задачу в C #?

Question

Что происходит, когда вы ожидаете асинхронную задачу в C #?

2

Из того, что я понял во всех уроках async/await в С#, я понял, что когда мы определяем асинхронный метод, это означает, что мы можем добавить в него ключевое слово await с задачей в качестве параметра, чтобы метод возвращался к вызывающей стороне, если задача слишком длинная Затем метод может возобновиться после завершения задачи.

public void MyMainMethod()
{
   DoSomethingAsync();
   KeepOnDoingOtherStuff();
}

public async Task DoSomethingAsync()
{
   //Do whatever
   await LongOperation();
   // Rest of the method that is executed when the long operation is 
    //finished.

}

Таким образом, здесь, пока выполняется длинная операция, как и ожидается, асинхронный DoSomething передает руку MainMethod и выполняется KeepOnDoingOtherStuff. Хорошо

Теперь моя проблема в том, что мой DoSomethingAsync сам по себе ожидается. В этом случае:

public async void MyMainMethod()
{
   await DoSomethingAsync();

   //Here is a critical method that I want to execute only when 
     //DoSomethingAsync is finished

   CriticalStuff();
}

public async Task DoSomethingAsync()
{
   //Do whatever
   await LongOperation();
   // Rest of the method that is executed when the long operation is 
    //finished.

}

Теперь я жду своего DoSomethingAsync, так что я уверен, что он не идет дальше, но проблема в том, что DoSomethingAsync() все еще дает руку вызывающей стороне, когда она ожидает LongOperation(), и мой метод Main возобновляется, что я и делаю не хочу, потому что он выполняет мою критическую вещь.

В асинхронной логике я кое-что упускаю. Какой смысл "ждать" метода, в котором есть асинхронные методы?

Я был бы очень признателен за решение моей проблемы.

Заранее спасибо.

Zeppelin 27 нояб. 2018, в 13:36

Источник

2

Во втором примере CriticalStuff() не должен вызываться до тех пор, пока DoSomethingAsync() будет полностью завершен. В коде примера, который вы разместили здесь, должно быть что-то не хватает.
user247702 27 нояб. 2018, в 12:01
0

Это хорошая статья об асинхронном программировании, если вам интересно больше узнать об этой теме. rubikscode.net/2018/05/28/...
lorandd 27 нояб. 2018, в 12:01
0

Ваш MyMainMethod () должен вернуть задачу, и все, что вызывает, должно ждать
auburg 27 нояб. 2018, в 12:02
2

«Проблема в том , что DoSomethingAsync () по- прежнему дает руку к абоненту , когда он ожидает LongOperation (), и мой метод Main продолжается» Он не должен ... await в нем должны позаботиться о том, что, так же , как await на LongOperation . Как говорит @Stijn, если это происходит, в вашем коде должно быть что-то еще, что вы не показываете.
James Thorpe 27 нояб. 2018, в 12:04
1

только когда DoSomethingAsync будет завершен в опубликованном вами коде, это именно то, что произойдет. Это не? Пожалуйста, создайте минимальный, полный и проверяемый пример вашей проблемы.
Liam 27 нояб. 2018, в 12:04
0

@JamesThorpe Ваш комментарий указывает на то, чего мне не хватает. Если я ожидаю задачу1, которая сама по себе является асинхронной, и в ней есть ожидающая задача 2, когда именно код считает задачу 1 завершенной и продолжает работу? Поскольку кажется, что как только я нажимаю await task2, он возвращается к вызывающей стороне, и код в вызывающей программе после выполнения await task1 выполняется ..
Zeppelin 27 нояб. 2018, в 13:14

Показать ещё 4 комментария

Теги:

c#

.net

asynchronous

2 ответа

Ещё вопросы

Во втором примере CriticalStuff() не должен вызываться до тех пор, пока DoSomethingAsync() будет полностью завершен. В коде примера, который вы разместили здесь, должно быть что-то не хватает.
Это хорошая статья об асинхронном программировании, если вам интересно больше узнать об этой теме. rubikscode.net/2018/05/28/...
Ваш MyMainMethod () должен вернуть задачу, и все, что вызывает, должно ждать
«Проблема в том , что DoSomethingAsync () по- прежнему дает руку к абоненту , когда он ожидает LongOperation (), и мой метод Main продолжается» Он не должен ... await в нем должны позаботиться о том, что, так же , как await на LongOperation . Как говорит @Stijn, если это происходит, в вашем коде должно быть что-то еще, что вы не показываете.
только когда DoSomethingAsync будет завершен в опубликованном вами коде, это именно то, что произойдет. Это не? Пожалуйста, создайте минимальный, полный и проверяемый пример вашей проблемы.
@JamesThorpe Ваш комментарий указывает на то, чего мне не хватает. Если я ожидаю задачу1, которая сама по себе является асинхронной, и в ней есть ожидающая задача 2, когда именно код считает задачу 1 завершенной и продолжает работу? Поскольку кажется, что как только я нажимаю await task2, он возвращается к вызывающей стороне, и код в вызывающей программе после выполнения await task1 выполняется ..

Marc Gravell · Answer 1 · 2018-11-27T09-39-00.000Z

Я думаю, что несоответствие здесь происходит от этих слов:

заставить метод вернуться к вызывающей стороне, если задача слишком длинная.

await не долго, точно. Это про асинхронный. Если что-то занимает много времени, но происходит на локальном процессоре, тогда точно: это не совсем подходит для await (хотя вы можете использовать механизм await в качестве удобного способа передачи данных в рабочий поток, а затем вернуться к синхронизации контекстный поток, когда он завершается).

Лучший пример, тем не менее, это когда задача внешняя; это может быть вызов базы данных SQL, или redis, или через http, или другому процессу через некоторый уровень ввода-вывода, или ожидание данных сокета. Обратите внимание, что даже общение с физически локальным хранилищем SSD может потребовать длительного ожидания, по крайней мере, измеряемого скоростью процессора. Когда локальный поток ничего не делает, кроме блокирования (ожидания ответа), тогда: во многих случаях есть гораздо лучшие вещи, которые поток может делать.

В случае клиентского приложения эти "лучшие вещи" включают в себя рисование пользовательского интерфейса и реагирование на ввод. В случае серверного приложения эти "лучшие вещи" включают обслуживание других одновременных запросов/загрузки.

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

Я понял но для меня смысл асинхронности DoSomethingAsync в том, что он может возвращаться к вызывающей стороне, пока он выполняет свою долгую операцию. Однако «вызывающая сторона» ожидает задачу DoSomethingAsync, поэтому она не будет ничего делать, пока она не завершена. Следовательно, я мог бы сделать DoSomethingAsync синхронным. Другими словами, почему любая Задача, которую мы ждем, будет асинхронной?
@Zeppelin вы говорите о параллелизме, а я говорю об асинхронности, связанной, но другой. Я в основном сосредотачиваюсь на асинхронности, и в этом случае ключевая вещь, которую вы пропускаете, это то, что потоки дороги , и что во многих сценариях есть несвязанные вещи, которые ваш поток мог бы с пользой делать, а не блокировать. С точки зрения того, что вы говорите о параллелизме: конечно, есть сценарии, в которых вы можете использовать async для координации 2 (или более) действий, и: это совершенно верно. Просто ... не await пока вы не будете готовы "присоединиться" (в терминах потоков)
@Zeppelin, чтобы выразить это в контексте: одна из вещей, которые я запускаю, это сервер веб-сокетов, который обслуживает около 60 тыс. TCP-соединений на экземпляр. Там нет никакого способа, которым я могу запустить потоки 60k (ну, 120k потоков - чтение + запись на сокет); исторические API асинхронного ввода-вывода ... очень трудно понять; выполнимо, но действительно очень сложно . Но: чтобы получить тот же результат с помощью async / await : сделать тривиально - действительно хороший простой код. Нет ничего, что await добавляет, что вы уже не могли бы сделать с более уродливым, сложным, мучительным кодом. Но await позволяет легко сделать это правильно .

Damien_The_Unbeliever · Answer 2 · 2018-11-27T10-30-00.000Z

Я обсуждаю этот вариант вашего кода:

public async void MyMainMethod()
{
   await DoSomethingAsync();

   //Here is a critical method that I want to execute only when 
     //DoSomethingAsync is finished

   CriticalStuff();
}

public async Task DoSomethingAsync()
{
   //Do whatever
   await LongOperation();
   // Rest of the method that is executed when the long operation is 
    //finished.

}

Когда DoSomethingAsync возвращается, он не просто слепо передает управление обратно вызывающему методу. Это вручает это Task. Если метод на самом деле завершен синхронно, он вернет задачу, которая уже выполнена. В противном случае, если у метода все еще есть работа, Task будет запущена, но еще не завершена.

Итак, DoSomethingAsync фактически запускает некоторое асинхронное поведение и возвращает обратно невыполненную Task в Main. Что Main делает с этим? await этого. await - это то, как этот метод указывает: "Я не могу сделать ничего полезного, если это ожидаемое (обычно Task) не выполнено".

Если (как здесь), Task еще не выполнена, она не продвигается дальше (сама), пока это не произойдет. Если это первое (обязательное) await в методе, именно в этот момент запускается асинхронный механизм, регистрируется продолжение и возвращается из самого Main.

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

(Я проигнорировал историю исключений в приведенном выше описании. Все это счастливые вещи)

Поэтому, когда вы говорите, что Main «не может сделать ничего полезного, пока DoSomethingAsync не будет завершен»: когда мы можем сказать, что он официально завершен? потому что в этой задаче есть другая задача, которая выполняется и ожидает (ожидайте LongOperation ()). Если я применяю логику: в DoSomethingAsync я нажимаю ожидающую ожидаемую LongOperation () -> она еще не завершена, поэтому мы возвращаемся к вызывающей стороне -> который является Главным, а что после ожидают DoSomethingAsync () .... (это то, чего я конкретно не хочу, так как ничего еще не закончено ..). Отсюда и моя путаница ...
@Zeppelin - Постараюсь формулируя это по- другому - всякий раз , когда вы нажмете await и на самом деле приходится ждать, то Task , которая представляет завершение этого вызова метода по - прежнему отмечена как бег, не завершена. Ваш метод не считается завершенным, пока эта Task перейдет к Complete . И это та Task которую ваш абонент, в свою очередь, может await . Есть яснее?
Таким образом, в примере: пока задача LongOperation () не перешла в Complete, мой DoSomethingAsync не сможет перейти в завершения, я прав?
Верный. С таким кодом нередко обнаруживается, что у вас есть несколько Task , каждая из которых представляет ожидающую активность для каждого асинхронного метода в стеке вызовов.
Так какой смысл делать асинхронную DoSomethingAsync? Я мог бы синхронно вызывать LongOperation (), это ничего не изменит, не так ли? Поскольку вызывающая сторона не может продолжать, пока моя LongOperation не завершен. Я не вижу смысла в том, чтобы Задание ожидалось внутри Задания, ожидаемого само по себе.
@Zeppelin - если await является окончательным утверждением в методе и является единственным await присутствуют в этом методе, мало смысл в принятии этого метода async . Однако вы указали, что DoSomethingAsync имеет // Rest of the method that is executed when the long operation is finished. LongOperation может быть завершен, но это не означает, что DoSomethingAsync - вот почему у каждого своя Task .
@Zeppelin - если у вас есть время, я бы посоветовал вам прочесть серию Эрика Липперта « Продолжение прохождения», серия « Возвращение » (ссылка на первую часть). На первый взгляд может показаться, что это не имеет никакого отношения к этому, но если вы дойдете до конца, вы сможете лучше увидеть некоторые из этих деталей.
Я согласен, но для меня смысл асинхронности DoSomethingAsync в том, что он может возвращаться к вызывающей стороне, пока он выполняет свою долгую работу. Однако «вызывающая сторона» ожидает задачу DoSomethingAsync, поэтому она не будет ничего делать, пока она не завершена. Следовательно, я могу сделать DoSomethingAsync синхронным, это ничего не изменит .. Спасибо за ссылку!