Аннотация: Асинхронное программирование в.NET Framework. Методы EndOperation, Pooling, Callback. Асинхронный запуск произвольного метода. Обновление интерфейса. Безопасность многопоточных приложений. Синхронизация: автоматическая, ручная; использование областей синхронизации. Элемент управления ProgressBar
Когда мы запускаем "долгий" метод, процессор будет выполнять его, при этом ему будет "некогда" выполнять другие запросы пользователя (рис. 7.2).
При синхронном выполнении у приложения есть только один поток. С помощью асинхронной модели программирования вы можете запускать множество параллельных потоков и во время их выполнения реагировать на новые действия пользователя. После того как n-поток выполнен, вы отображаете результат на экран.
В обычной жизни есть масса примеров асинхронного поведения - пополнение запасов сырья на складе позволяет обеспечить фабрике бесперебойную работу. Несинхронной моделью будет полное использование сырья и последующий простой в ожидании подвоза материала.
Поддержка асинхронного программирования в.NET Framework
Классы, в которых есть встроенная поддержка асинхронной модели , имеют пару асинхронных методов для каждого из синхронных методов. Эти методы начинаются со слов Begin и End. Например, если мы хотим воспользоваться асинхронным вариантом метода Read класса System.IO.Stream, нам нужно использовать методы BeginRead и EndRead этого же класса.
Для использования встроенной поддержки асинхронной модели программирования нужно вызвать соответствующий метод BeginOperation и выбрать модель завершения вызова. Вызов метода BeginOperation возвращает объект интерфейса IAsyncResult , с помощью которого определяется состояние выполнения асинхронной операции. Завершить выполнение асинхронных методов можно несколькими способами.
Метод EndOperation
Метод EndOperation применяется для завершения асинхронного вызова в тех случаях, когда основному потоку необходимо проделать большой объем вычислений, не зависящих от результатов вызова асинхронного метода. После того как основная работа сделана и приложение нуждается в результатах выполнения асинхронного метода для дальнейших действий, вызывается метод EndOperation . При этом основной поток будет приостановлен до завершения работы асинхронного метода. Пример использования этого способа:
Using System; using System.IO; namespace EndOperation { class Class1 { static void Main(string args) { //Создаем поток и открываем файл. FileStream fs = new FileStream("text.txt", FileMode.Open); byte fileBytes = new byte; // Запуск метода Read в параллельном потоке. IAsyncResult ar = fs.BeginRead(fileBytes, 0, fileBytes.Length, null, null); for(int i = 0; i<10000000; i++) { // Имитация длительной работы основного // потока, не зависящая от выполнения асинхронного метода. } // После завершения работы основного потока // запускаем завершение выполнения параллельного // метода Read. fs.EndRead(ar); Console.Write(System.Text.Encoding.Default.GetString(fileBytes)); } } } Листинг 7.1.
Для завершения выполнения параллельного потока ar здесь был вызван метод EndRead . В качестве кода, имитирующего длительную работу, можно подключить точный счетчик выполнения задачи, разобранный нами в "Использование библиотек кода в windows-формах" .
Способ опроса (Pooling)
Этот способ подходит в случаях, когда требуется контролировать выполнение асинхронного метода. При его использовании приходится осуществлять проверку выполнения асинхронного метода вручную, с помощью свойства IsCompleted объекта типа IAsyncResult . Это не самая распространенная техника завершения, поскольку большинство процессов не требует контроля выполнения. Пример использования способа опроса:
Using System; using System.IO; namespace Pooling { class Class1 { static void Main(string args) { FileStream fs = new FileStream("text.txt", FileMode.Open); byte fileBytes = new byte; Console.Write("Выполнение метода Read асинхронно."); // Запуск метода Read асинхронно. IAsyncResult ar = fs.BeginRead(fileBytes, 0, fileBytes.Length, null, null); // Проверка на выполнение асинхронного метода. while(!ar.IsCompleted) { // Во время чтения файла на экран выводится надпись Console.Write("Процесс идет"); } Console.WriteLine(); string textFromFile = System.Text.Encoding.Default.GetString(fileBytes); Console.Write(textFromFile); } } } Листинг 7.2.
Вероятнее всего, вы не заметите появления надписи в течение процесса - файл будет считан слишком быстро. Для тестирования этого способа запишите большой текстовый файл на дискету, укажите адрес и попробуйте снова запустить приложение.
Способ Callback
Способ завершения асинхронного вызова Callback используется в тех случаях, когда нужно предотвратить блокирование основного потока. При использовании Callback мы запускаем метод EndOperation в теле метода, который вызывается при завершении метода, работающего в параллельном потоке. Сигнатура вызываемого метода должна совпадать с сигнатурой делегата AsyncCallback .
Пример использования варианта Callback :
Using System;
using System.IO;
namespace Callback
{
class Class1
{
// Создаем поток и массив байтов.
static FileStream fs;
static byte fileBytes;
static void Main(string args)
{
// Открываем файл в поток.
fs = new FileStream("text.txt", FileMode.Open);
fileBytes = new byte;
// Запускаем метод Read асинхронно с передачей в качестве Сallback
// метода WorkComplete
fs.BeginRead(fileBytes, 0, (int)fs.Length, new AsyncCallback(WorkComplete), null);
}
///
На диске, прилагаемом к книге, вы найдете приложения EndOperation , Pooling и Callback (Code\Glava7\ EndOperation, Pooling, Callback).
Последнее обновление: 31.10.2015
В прошлых темах было рассмотрено применение асинхронности с использованием ключевым слов async и await. Но кроме подобной модели использования асинхронных вызовов в C# имеется и другая модель - использование асинхронных делегатов. Асинхронные делегаты широко использовались до появления в C# async и await, сейчас же async и await существенно упрощают написание асинхронного кода. Тем не менее асинхронные делегаты по прежнему могут применяться. Поэтому рассмотрим их.
Асинхронные делегаты позволяют вызывать методы, на которые эти делегаты указывают, в асинхронном режиме. В теме про делегаты говорилось, что делегаты могут вызываться как с помощью метода Invoke , так и в асинхронном режиме с помощью пары методов BeginInvoke/EndInvoke . Рассмотрим на примере. Вначале посмотрим, что будет, если мы будем использовать обычный синхронный код в нашем приложении:
Using System; using System.Threading; namespace AsyncApp { class Program { public delegate int DisplayHandler(); static void Main(string args) { DisplayHandler handler = new DisplayHandler(Display); int result = handler.Invoke(); Console.WriteLine("Продолжается работа метода Main"); Console.WriteLine("Результат равен {0}", result); Console.ReadLine(); } static int Display() { Console.WriteLine("Начинается работа метода Display...."); int result = 0; for (int i = 1; i < 10; i++) { result += i * i; } Thread.Sleep(3000); Console.WriteLine("Завершается работа метода Display...."); return result; } } }
Здесь создается специальный делегат DisplayHandler, который в качестве ссылки принимает метод без параметров, который возвращает число. В данном случае таким методом является метод Display, который выполняет какую-то работу. В этом случае мы получим примерно следующий вывод:
Начинается работа метода Display.... Завершается работа метода Display.... Продолжается работа метода Main Результат равен 285
В общем-то можно было и не использовать делегат и напрямую вызвать метод Display. Но в любом случае после его вызова дальше блокируется работа метода Main, пока не завершится выполнение метода Display.
Теперь изменим пример с применением асинхронных вызовов делегата:
Using System; using System.Threading; namespace AsyncApp { class Program { public delegate int DisplayHandler(); static void Main(string args) { DisplayHandler handler = new DisplayHandler(Display); IAsyncResult resultObj = handler.BeginInvoke(null, null); Console.WriteLine("Продолжается работа метода Main"); int result = handler.EndInvoke(resultObj); Console.WriteLine("Результат равен {0}", result); Console.ReadLine(); } static int Display() { Console.WriteLine("Начинается работа метода Display...."); int result = 0; for (int i = 1; i < 10; i++) { result += i * i; } Thread.Sleep(3000); Console.WriteLine("Завершается работа метода Display...."); return result; } } }
Суть действий практически не изменилась, тот же метод Display, только теперь он вызывается в асинхронном режиме с помощью методов BedinInvoke/EndInvoke . И теперь мы можем получить немного другой вывод:
Начинается работа метода Display.... Продолжается работа метода Main Завершается работа метода Display.... Результат равен 285
Таким образом, после вызова метода Display через выражение handler.BeginInvoke(null, null) работа метода Main не приостанавливается. А выполнение метода Display через делегат DisplayHandler происходит в другом потоке. И лишь когда выполнение в методе Main дойдет до строки int result = handler.EndInvoke(resultObj); он блокируется и ожидает завершения выполнения метода Display.
Теперь рассмотрим особенности использования методов BeginInvoke и EndInvoke и интерфейса IAsyncResult.
С некоторых пор я получаю много вопросов об асинхронном программировании. И, поняв, что данная тема интересует многих моих читателей, я решил написать статью, для объяснения этих терминов, тем более, что асинхронное программирование является очень важной частью современного Интернета.
Для начала необходимо отметить, что существуют две совершенно разные концепции: первая - синхронная и асинхронная модели программирования , а вторая - однопоточные и многопоточные среды . Каждая из моделей программирования (синхронная и асинхронная) может работать как в однопоточной, так и в многопоточной среде.
Модель синхронного программирования.
В этой модели программирования поток назначается одной задаче и начинает работать над ней. Как только задача завершается, поток доступен для следующей задачи. Т.е. одна задача сменятся другой последовательно. В этой модели невозможно оставить выполнение задачи в середине для выполнения другой задачи. Давайте обсудим, как эта модель работает в однопоточных и многопоточных средах.
Однопоточная среда - Single Threaded - если у нас есть пара задач, которые необходимо выполнить, а текущая система предоставляет только один поток, тогда задачи назначаются потоку одна за другой. Наглядно это можно изобразить вот так:
Где Thread 1 - один поток, Task 1 и Task 2, Task 3, Task 4 – соответствующие задачи.
Мы видим, что у нас есть поток (Thread 1 ) и четыре задачи , которые нужно выполнить. Поток начинает работу над задачами и завершает все задачи одну за другой.
Многопоточная среда - Multi-Threaded - в этой среде мы используем несколько потоков, которые могут выполнять эти задачи одновременно. Это означает, что у нас есть пул потоков (новые потоки также могут создаваться по необходимости на основе доступных ресурсов) и множество задач.
Мы видим, что у нас есть четыре потока и столько же задач. Поэтому каждый поток выполняет одну задачу и завершает ее. Это идеальный сценарий, но в обычных условиях у нас, как правило, больше задач, чем количество доступных потоков. И поэтому, когда один поток закончит выполнять некоторую задачу, он немедленно приступит к выполнению другой. Обратите внимание также и на тот факт, что новый поток создается не каждый раз, потому что ему нужны системные ресурсы, такие как такты процессора и память, которых может оказаться недостаточно.
Теперь давайте поговорим об асинхронной модели и о том, как она ведет себя в однопоточной и многопоточной среде.
Модель асинхронного программирования.
В отличие от модели синхронного программирования, здесь один поток, запуская некую задачу, может остановить на некотором промежутке времени ее выполнения, сохраняя при этом ее текущее состояние, и начать выполнять другую задачу .
мы видим, что один поток отвечает за выполнение всех задач, чередуя их, друг с другом.
Если наша система способна создавать несколько потоков, то все потоки могут работать по асинхронной модели.
Мы видим, что те же задачи T4, T5, T6 обрабатываются несколькими потоками. В этом и состоит красота и сила этого сценария. Как вы можете видеть, задача T4 была запущена первой в потоке Thread 1 и завершена в потоке Thread 2 . Точно так же T6 завершается в Thread 2, Thread 3 и Thread 4 .
Итак, всего у нас четыре сценария –
- Синхронный однопоточный
- Синхронный многопоточный
- Асинхронный однопоточный
- Асинхронный многопоточный
Преимущества асинхронного программирования
Для любого приложения важны две вещи: удобство использования и производительность. Удобство использования важно потому, что когда пользователь нажимает кнопку, чтобы сохранить некоторые данные, это требует выполнения нескольких небольших задач, таких как чтение и заполнение данных во внутреннем объекте, установление соединения с SQL сервером и сохранение запроса там и. т. д.
Так как SQL-сервер , например, скорее всего, работает на другом компьютере в сети и работает под другим процессом, это может занять много времени. А, если приложение работает в одном потоке, тогда экран устройства пользователя будет находиться в неактивном состоянии до тех пор, пока все задачи не будут завершены, что является примером очень плохого пользовательского интерфейса. Вот почему многие приложения и новые фреймворки полностью полагаются на асинхронную модель, так как она позволяет выполнять множество задач, при этом сохраняя отзывчивость интерфейса.
Эффективность приложения также очень важна. Подсчитано, что при выполнении запроса около 70-80% времени теряется в ожидании зависимых задач. Поэтому, это место где асинхронное программирование как нельзя лучше придется кстати.
Таким образом, в данной статье мы рассмотрели, что такое синхронное и асинхронного программирование. Особый акцент был сделан на асинхронное программирование, так оно лежит в основе подавляющего большинства современных средств разработки. А в следующих статьях мы познакомимся с реальными примерами, использующими асинхронную модель.
Попробую собрать воедино все, что дали уже в комментариях.
Есть несколько разных понятий, связанных с областью параллельных вычислений.
- Конкурентное исполнение (concurrency)
- Параллельное исполнение (parallel execution)
- Многопоточное исполнение (multithreading)
- Асинхронное исполнение (asynchrony)
Каждый из этих терминов строго определен и имеет четкое значение.
Конкурентность (concurrency)
Конкурентность (*) (concurrency) - это наиболее общий термин, который говорит, что одновременно выполняется более одной задачи. Например, вы можете одновременно смотреть телевизор и комментить фоточки в фейсбуке. Винда, даже 95-я могла (**) одновременно играть музыку и показывать фотки.
(*) К сожалению, вменяемого русскоязычного термина я не знаю. Википедия говорит, что concurrent computing - это параллельные вычисления, но как тогда будет parallel computing по русски?
(**) Да, вспоминается анекдот про Билла Гейтса и многозадачность винды, но, теоретически винда могла делать несколько дел одновременно. Хотя и не любых.
Конкурентное исполнение - это самый общий термин, который не говорит о том, каким образом эта конкурентность будет получена: путем приостановки некоторых вычислительных элементов и их переключение на другую задачу, путем действительно одновременного исполнения, путем делегации работы другим устройствам или еще как-то. Это не важно.
Конкурентное исполнение говорит о том, что за определенный промежуток времени будет решена более, чем одна задача. Точка.
Параллельное исполнение
Параллельное исполнение (parallel computing) подразумевает наличие более одного вычислительного устройства (например, процессора), которые будут одновременно выполнять несколько задач.
Параллельное исполнение - это строгое подмножество конкурентного исполнения. Это значит, что на компьютере с одним процессором параллельное программирование - невозможно;)
Многопоточность
Многопоточность - это один из способов реализации конкурентного исполнения путем выделения абстракции "рабочего потока" (worker thread).
Потоки "абстрагируют" от пользователя низкоуровневые детали и позволяют выполнять более чем одну работу "параллельно". Операционная система, среда исполнения или библиотека прячет подробности того, будет многопоточное исполнение конкурентным (когда потоков больше чем физических процессоров), или параллельным (когда число потоков меньше или равно числу процессоров и несколько задач физически выполняются одновременно).
Асинхронное исполнение
Асинхронность (asynchrony) подразумевает, что операция может быть выполнена кем-то на стороне: удаленным веб-узлом, сервером или другим устройством за пределами текущего вычислительного устройства.
Основное свойство таких операций в том, что начало такой операции требует значительно меньшего времени, чем основная работа. Что позволяет выполнять множество асинхронных операций одновременно даже на устройстве с небольшим числом вычислительных устройств.
CPU-bound и IO-Bound операции
Еще один важный момент, с точки зрения разработчика - разница между CPU-bound и IO-bound операциями. CPU-Bound операции нагружают вычислительные мощности текущего устройства, а IO-Bound позволяют выполнить задачу вне текущей железки.
Разница важна тем, что число одновременных операций зависит от того, к какой категории они относятся. Вполне нормально запустить параллельно сотни IO-Bound операций, и надеяться, что хватит ресурсов обработать все результаты. Запускать же параллельно слишком большое число CPU-bound операций (больше, чем число вычислительных устройств) бессмысленно.
Возвращаясь к исходному вопросу: нет смысла выполнять в 1000 потоков метод Calc , если он является CPU-Intensive (нагружает центральный процессор), поскольку это приведет к падению общей эффективности вычислений. ОС-ке придется переключать несколько доступных ядер для обслуживания сотен потоков. А этот процесс не является дешевым.
Самым простым и эффективным способом решения CPU-Intensive задачи, заключается в использовании идиомы Fork-Join: задачу (например, входные данные) нужно разбить на определенное число подзадач, которые можно выполнить параллельно. Каждая подзадача должна быть независимой и не обращаться к разделяемым переменным/памяти. Затем, нужно собрать промежуточные результаты и объединить их.
Выглядит это очень интересно:
IEnumerable yourData = GetYourData(); var result = yourData.AsParallel() // начинаем обрабатывать параллельно.Select(d => ComputeMD5(d)) // Вычисляем параллельно.Where(md5 => IsValid(md5)) .ToArray(); // Возврвщаемся к синхронной модели
В этом случае, число потоков будет контролироваться библиотечным кодом в недрах CLR/TPL и метод ComputeMD5 будет вызван параллельно N-раз на компьютере с N-процессорами (ядрами).
Последнее обновление: 17.10.2018
Асинхронность позволяет вынести отдельные задачи из основного потока в специальные асинхронные методы или блоки кода. Особенно это актуально в графических программах, где продолжительные задачи могу блокировать интерфейс пользователя. И чтобы этого не произошло, нужно задействовать асинхронность. Также асинхронность несет выгоды в веб-приложениях при обработке запросов от пользователей, при обращении к базам данных или сетевым ресурсам. При больших запросах к базе данных асинхронный метод просто уснет на время, пока не получит данные от БД, а основной поток сможет продолжить свою работу. В синхронном же приложении, если бы код получения данных находился в основном потоке, этот поток просто бы блокировался на время получения данных.
Ключевыми для работы с асинхронными вызовами в C# являются два ключевых слова: async и await , цель которых - упростить написание асинхронного кода. Они используются вместе для создания асинхронного метода.
Асинхонный метод обладает следующими признаками:
ValueTask
В заголовке метода используется модификатор async
Метод содержит одно или несколько выражений await
В качестве возвращаемого типа используется один из следующих:
Асинхронный метод, как и обычный, может использовать любое количество параметров или не использовать их вообще. Однако асинхронный метод не может определеять параметры с модификаторами out и ref .
Также стоит отметить, что слово async , которое указывается в определении метода, не делает автоматически метод асинхронным. Оно лишь указывает, что данный метод может содержать одно или несколько выражений await .
Рассмотрим пример асинхронного метода:
Using System; using System.Threading; using System.Threading.Tasks; namespace HelloApp { class Program { static void Factorial() { int result = 1; for(int i = 1; i <= 6; i++) { result *= i; } Thread.Sleep(8000); Console.WriteLine($"Факториал равен {result}"); } // определение асинхронного метода static async void FactorialAsync() { Console.WriteLine("Начало метода FactorialAsync"); // выполняется синхронно await Task.Run(()=>Factorial()); // выполняется асинхронно Console.WriteLine("Конец метода FactorialAsync"); } static void Main(string args) { FactorialAsync(); // вызов асинхронного метода Console.WriteLine("Введите число: "); int n = Int32.Parse(Console.ReadLine()); Console.WriteLine($"Квадрат числа равен {n * n}"); Console.Read(); } } }
Здесь прежде всего определен обычный метод подсчета факториала. Для имитации долгой работы в нем используется задержка на 8 секунд с помощью метода Thread.Sleep() . Условно это некоторый метод, который выполняет некоторую работу продолжительное время. Но для упрощения понимания он просто подсчитывает факториал числа 6.
Также здесь определен асинхронный метод FactorialAsync() . Асинхронным он является потому, что имеет в определении перед возвращаемым типом модификатор async , его возвращаемым типом является void, и в теле метода определено выражение await .
Выражение await определяет задачу, которая будет выполняться асинхронно. В данном случае подобная задача представляет выполнение функции факториала:
Await Task.Run(()=>Factorial());
По негласным правилам в названии асинхроннных методов принято использовать суффикс Async - FactorialAsync () , хотя в принципе это необязательно делать.
Сам факториал мы получаем в асинхронном методе FactorialAsync . Асинхронным он является потому, что он объявлен с модификатором async и содержит использование ключевого слова await .
И в методе Main мы вызываем этот асинхронный метод.
Посмотрим, какой у программы будет консольный вывод:
Начало метода FactorialAsync Введите число: 7 Квадрат числа равен 49 Конец метода Main Факториал равен 720 Окончание метода FactorialAsync
Разберем поэтапно, что здесь происходит:
Запускается метод Main, в котором вызывается асинхронный метод FactorialAsync.
Метод FactorialAsync начинает выполняться синхронно вплоть до выражения await.
Выражение await запускает асинхронную задачу Task.Run(()=>Factorial())
Пока выполняется асинхронная задача Task.Run(()=>Factorial()) (а она может выполняться довольно продожительное время), выполнение кода возвращается в вызывающий метод - то есть в метод Main. В методе Main нам будет предложено ввести число для вычисления квадрата числа.
В этом и преимущество асинхронных методов - асинхронная задача, которая может выполняться довольно долгое время, не блокирует метод Main, и мы можем продолжать работу с ним, например, вводить и обрабатывать данные.
Когда асинхронная задача завешила свое выполнение (в случае выше - подсчитала факториал числа), продолжает работу асинхронный метод FactorialAsync, который вызвал асинхронную задачу.
Функция факториала, возможно, представляет не самый показательный пример, так как в реальности в данном случае нет смысла делать ее асинхронной. Но рассмотрим другой пример - чтение-запись файла:
Using System; using System.Threading; using System.Threading.Tasks; using System.IO; namespace HelloApp { class Program { static async void ReadWriteAsync() { string s = "Hello world! One step at a time"; // hello.txt - файл, который будет записываться и считываться using (StreamWriter writer = new StreamWriter("hello.txt", false)) { await writer.WriteLineAsync(s); // асинхронная запись в файл } using (StreamReader reader = new StreamReader("hello.txt")) { string result = await reader.ReadToEndAsync(); // асинхронное чтение из файла Console.WriteLine(result); } } static void Main(string args) { ReadWriteAsync(); Console.WriteLine("Некоторая работа"); Console.Read(); } } }
Асинхронный метод ReadWriteAsync() выполнение запись в файл некоторой строки и затем считывает записанный файл. Подобные операции могут занимать продолжительное время, особенно при больших объемах данных, поэтому такие операции лучше делать асинхронными.
Фреймворк.NET уже имеет встроенную поддержку таких операций. Например, в классе StreamWriter определен метод WriteLineAsync() . По сути он уже представляет асинхронную операцию и принимает в качестве параметра некоторую строку, которую надо записать в файл. Поскольку этот метод представляет асинхронную операцию, то вызов этого метода мы можем оформить в выражение await :
Await writer.WriteLineAsync(s); // асинхронная запись в файл
Аналогично в классе StreamReader определен метод ReadToEndAsync() , который также представляет асинхронную операцию и который возвращает весь считанный текст.
Во фреймворке.NET Core определено много подобных методов. Как правило, они связаны с работой с файлами, отправкой сетевых запросов или запросов к базе данных. Их легко узнать по суффиксу Async . То есть если метод имеет подобный суффикс в названии, то с большей степенью вроятности его можно использовать в выражении await.
Static void Main(string args) { ReadWriteAsync(); Console.WriteLine("Некоторая работа"); Console.Read(); }
И опять же когда выполнение в методе ReadWriteAsync доходит до первого выражения await, управление возвращается в метод Main, и мы можем продолжать с ним работу. Запись в файл и считывания файла будут производиться параллельно и не будут блокировать работу метода Main.
Определение асинхронной операции
Как, выше уже было сказано, фреймворк.NET Core имеет много встроенных методов, которые представляют асинхронную операцию. Они заканчиваются на суффикс Async. И перед вызывами подобных методов мы можем указывать оператор await . Например:
StreamWriter writer = new StreamWriter("hello.txt", false); await writer.WriteLineAsync("Hello"); // асинхронная запись в файл
Либо мы сами можем определить асинхронную операцию, используя метод Task.Run() :
Static void Factorial() { int result = 1; for (int i = 1; i <= 6; i++) { result *= i; } Thread.Sleep(8000); Console.WriteLine($"Факториал равен {result}"); } // определение асинхронного метода static async void FactorialAsync() { await Task.Run(()=>Factorial()); // вызов асинхронной операции }
Можно определить асинхронную операцию с помощью лямбда-выражения:
Static async void FactorialAsync() { await Task.Run(() => { int result = 1; for (int i = 1; i <= 6; i++) { result *= i; } Thread.Sleep(8000); Console.WriteLine($"Факториал равен {result}"); }); }
Передача параметров в асинхронную операцию
Выше вычислялся факториал 6, но, допустим, мы хотим вычислять факториалы разных чисел:
Using System; using System.Threading; using System.Threading.Tasks; namespace HelloApp { class Program { static void Factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } Thread.Sleep(5000); Console.WriteLine($"Факториал равен {result}"); } // определение асинхронного метода static async void FactorialAsync(int n) { await Task.Run(()=>Factorial(n)); } static void Main(string args) { FactorialAsync(5); FactorialAsync(6); Console.WriteLine("Некоторая работа"); Console.Read(); } } }
Получение результата из асинхронной операции
Асинхронная операция может возвращать некоторый результат, получить который мы можем так же, как и при вызове обычного метода:
Using System; using System.Threading; using System.Threading.Tasks; namespace HelloApp { class Program { static int Factorial(int n) { int result = 1; for (int i = 1; i <= n; i++) { result *= i; } return result; } // определение асинхронного метода static async void FactorialAsync(int n) { int x = await Task.Run(()=>Factorial(n)); Console.WriteLine($"Факториал равен {x}"); } static void Main(string args) { FactorialAsync(5); FactorialAsync(6); Console.Read(); } } }
Метод Factorial возвращает значение типа int, это значение мы можем получить, просто присвоив результат асинхронной операции переменной данного типа: int x = await Task.Run(()=>Factorial(n));
