async clinic by by sergey teplyakov

Асинхронное программирование

Сергей Тепляков, Visual C# MVP.NET Architect at Luxoft

SergeyTeplyakov.blogspot.com

Sync vs Async

SynchronousPerform something here and now.I’ll regain control to execute something else when it’s done.

AsynchronousInitiate something here and now.I’ll regain control to execute something else “immediately”.

Эволюцияязыка C#

Sync vs AsyncCaller Srv

Foo

42

Caller Srv

Operation finishedResult: 42

FooAsync

Operation Started

Bckgn

Starting background operation

Notifies

t

t

t0

Sync vs Async

Sync vs Asyncvar webRequest = WebRequest.Create(Url); using (var response = webRequest.GetResponse()) {     using (var file = new FileStream(FileName,          FileMode.OpenOrCreate))     {         var length = response.ContentLength;         var textWriter = new StreamWriter(file);         textWriter.Write(length.ToString());         textWriter.Close();     } }

Sync vs Async (2)var webRequest = WebRequest.Create(Url); using (var response = await webRequest.GetResponseAsync()) {     using (var file = new FileStream(FileName,          FileMode.OpenOrCreate))     {         var length = response.ContentLength;         var textWriter = new StreamWriter(file);         await textWriter.WriteAsync(length.ToString());         textWriter.Close();     } }

!Копайте в глубьВсе нетривиальные абстракции дырявыДжоэл Спольски «Закон дырявых абстракций»

Вы должны понимать как минимум на один уровень абстракции ниже того уровня, на котором вы кодируетеЛи Кэмпбел (Lee Campbell)

Async/await – лишьвершина

Async/Await Samplepublic async Task AsyncMethod(string url, string fileName){    var webRequest = WebRequest.Create(url);    Task<WebResponse> tResp = webRequest.GetResponseAsync();    WebResponse response = await tResp;

    var responseStream = response.GetResponseStream();                 var tr = new StreamReader(responseStream);    Task<string> tContent = tr.ReadToEndAsync();    string content = await tContent;

    var file = File.OpenWrite(fileName);    var streamWriter = new StreamWriter(file);    Task writeResult = streamWriter.WriteAsync(content);    await writeResult;

Console.WriteLine("AsyncMethod finished");}

Async/Await SampleКод Потокvar webRequest = WebRequest.Create(url);Task<WebResponse> tResp = webRequest.GetResponseAsync();

Вызывающий поток

Await возвращает управление вызывающему кодуWebResponse response = await tResp;var responseStream = response.GetResponseStream();             var tr = new StreamReader(responseStream);Task<string> tContent = tr.ReadToEndAsync();

Поток 2

Await возвращает управление вызывающему кодуstring content = await tContent; var file = File.OpenWrite(fileName);var streamWriter = new StreamWriter(file);Task writeResult = streamWriter.WriteAsync(content);

Поток 3

Await возвращает управление вызывающему кодуawait writeResult;Console.WriteLine("AsyncMethod finished");

Поток 4

Метод завершен успешно

Async vs. Taskspublic async Task SimpleAsync(string url){    var webRequest = WebRequest.Create(url);    Task<WebResponse> tResp = webRequest.GetResponseAsync();    WebResponse response = await tResp;    Console.WriteLine("Got the response");}

public Task AsyncMethodImpl(string url){    var webRequest = WebRequest.Create(url);    Task<WebResponse> tResp = webRequest.GetResponseAsync();    return tResp.ContinueWith(t =>        {            Console.WriteLine("Got the response");        }, TaskScheduler.FromCurrentSynchronizationContext());}

Synchronization Context• Некоторые типы приложений налагают ограничения на

«потоковую» модель• Control.Invoke/BeginInvoke• Dispatcher.Invoke/BeginInvoke

• Контекст синхронизации «прячет» эти детали за абстрактным интерфейсом

• Контекст нужен для «маршалинга» управления из одного потока в другой (*)

• Контексты повсюду!

?Зачеммнеэто Яжепрограммируюна C#

5.0!

?Чтобудет в этомслучаеprivate async Task<int> Foo(){    buttonRun.Enabled = false;    await LongRunningTask();    buttonRun.Enabled = true;    return 42;}

private void btn_Click(object sender, EventArgs e) {     label.Text = FooAsync().Result.ToString(); }

«Продолжение» должно вызываться в UI потоке

Ожидает завершения асинхронной операции

Захватываем Sync Context

Возвращает управление!

“Sync over Async” + UI == Deadlock!

Решениеprivate async Task<int> Foo(){    buttonRun.Enabled = false;    await LongRunningTask();    buttonRun.Enabled = true;    return 42;}

private async void buttonRun_Click(object sender, EventArgs e){    textBoxStatus.Text = "";    textBoxStatus.Text = (await Foo()).ToString();}

Паттерныасинхронногопрограммирования• Asynchronous Programming Model (APM)

• BeginInvoke/EndInvoke• Event-Based Async Pattern (EAP)

• BackgroundWorker: RunWorkerAsync, RunWorkerCompleted• Bicycle –Async Pattern (BAP)

• Кастомные решения• Task-Based Async Pattern (TAP)

• Task<int> ReadAsync

Exception Handling

Task.ResultTask.Wait

await task; FirstException

AggregateExceptionfails

fails

Demo. Exception Handling

?Гдевылетитошибкаvar ms = new MemoryStream();           

// Здесь? Task<int> task = ms.ReadAsync(null, 0, 42);

// Или здесь? int result = task.Result;

• Является исключение «синхронным» или «асинхронным»?

« » Наивная реализацияpublic static async Task<int> ReadAsync(byte[] buffer) {     if (buffer == null)          throw new ArgumentNullException("buffer");

    // Реализация асинхронного чтения     return 42; }

Результирующая задача перейдет в Faulted состояние!

• Синхронное исключение означает «баг» в вызывающем коде.

• «Поломанная» задача означает баг в реализации!

Зачем заморачиваться?

Корректнаяреализацияpublic static Task<int> ReadAsync(byte[] buffer) {     if (buffer == null)          throw new ArgumentNullException("buffer");

    return ReadAsyncImpl(buffer); }

private static async Task<int> ReadAsyncImpl(byte[] buffer) {     // Реализация асинхронногочтения     return 42; }

Синхронная проверка «предусловий»

Demo. Exception Handling

Обработканесколькихисключенийpublic static async Task FooAsync() {     // t1 "падает"     Task<int> t1 = Task<int>.Factory.StartNew(() =>     {         throw new Exception("E1");     });

    // t2 тоже "падает"     Task<int> t2 = Task<int>.Factory.StartNew(() =>     {         throw new Exception("E2");     });

    int r1 = await t1;     int r2 = await t2; }

Получим “E1”?

Получим “E2”?

Получим AggregateException?

UnobservedTaskException!

Unobserved Exceptions• Событие TaskScheduler.UnobservedException• Генерируется финализатором• Не вызывается при обращении к

• Result• Exception • Вызове Wait

• Поведение зависит от версии .NET Framework• .NET 4.5 – «умалчивается» (*)• .NET 4.0 – «ломает» приложение

Await исключенийpublic static async Task<int> SimpleAsync() {     throw new CustomException(); }

public static async void ConsumeSimpleAsync() {     var task = SimpleAsync();     try     {         // "Разыменовывание" задачи приводит к         // "разворачиванию" первого исключения!         int result = await task;     }     catch (CustomException)     {         Console.WriteLine("Yahoo!!!");     } }

“Решение”public static async Task FooAsync(){    // t1 "падает"    Task<int> t1 = Task<int>.Factory.StartNew(() =>    {        throw new Exception("E1");    });

    // t2 тоже "падает"    Task<int> t2 = Task<int>.Factory.StartNew(() =>    {        throw new Exception("E2");    });

    // "Наблюдаем" оба исключения    var task = Task.WhenAll(t1, t2);

   await task.ContinueWith(_ => _.Result);     

   int r1 = t1.Result;    int r2 = t2.Result;}

«Объединяем» обе задачи

await task; пробросил бы лишь первое исключение!Явно генерируем AggregateException!!!!

?Икакэтоделоловитьvar task = Modified.FooAsync(); try {     await task; } // Для случая более одного исключения catch (AggregateException e) {     // "Выпрямляем" все исключения     int count = e.Flatten().InnerExceptions.Count;     Console.WriteLine( "Demo2.Modified.FooAsync failed with {0} exceptions",  count); } // Для более простых случаев catch (CustomException e) { } catch (Exception e) {}

Асинхронныеметоды• Типы возвращаемого значения асинхронного метода:

• async void FooAasync() – Fire and Forget (*)• async Task FooAsync() – (void Foo())• async Task<T> FooAsync() – (T Foo())

Demo. Async Void

Async Guidelines• Async void – это операции вида “fire-and-forget”• Вызывающий код не может узнать о завершении

асинхронного метода• Вызывающий код не может обработать исключения

(вместо этого они попадут в цикл обработки UI сообщений)

• Используйте async void только для обработчиков событий самого высокого уровня.

• Используйте возвращаемые значения!• Осторожнее с асинхронными лямбда-выражениями!

…Сколькожетут всего• Влияние TAP на дизайн приложения!• Обработка исключений

• Unobserved exceptions• Bugs vs Task Faults

• Гранулярность асинхронных операций• Testability• Work stealing• Async Programming Guidelines

• Avoid “async void”• Avoid async lambdas• Consider performance impact• Avoid “Sync over Async”• Avoid “Async over Sync”• Consider using ConfigureAwait

Вот этогоненадо

- Как вы пишите софт?- Бац-бац и в продакшн (с).

- Как из синхронного приложения сделать асинхронное?- Async/await и готово!

?Вопросы

Спасибо за внимание

• Сергей Тепляков, Visual C# MVP• .NET Architect at Luxoft• Sergey.Teplyakov@gmail.com• http://sergeyteplyakov.blogspot.com/

Чтодумаетпоэтому поводу Eric Lippert?

Q: C# 5.0 has new feature called async/await. Why should developers be excited about it?A: People like me, are excited about this feature because its a cooperative multitasking with coroutines implementing using continuation passing style.