## Задачи и класс Task

### 1

```
Task task1 = new Task(
    () => Console.WriteLine("Task1 is executed"));
task1.Start();

Task task2 = Task.Factory.StartNew(
    () => Console.WriteLine("Task2 is executed"));

Task task3 = Task.Run(
    () => Console.WriteLine("Task3 is executed"));
   
Console.ReadLine();
```
### выовод: 
Z:/oap/labs/lab5_multithreading/ConsoleApp2/ConsoleApp2/bin/Debug/net8.0/ConsoleApp2.exe
Task1 is executed
Task3 is executed
Task2 is executed

### 2

```
Task task = Task.Run(
    () => Console.WriteLine("Hello Task!")
);
```
### вывод:
```
Z:/oap/labs/lab5_multithreading/ConsoleApp2/ConsoleApp2/bin/Debug/net8.0/ConsoleApp2.exe

Process finished with exit code 0.
```

### 3
```
using System;
using System.Threading.Tasks;
 
Task task1 = new Task(
    () => Console.WriteLine("Task1 is executed"));
task1.Start();

Task task2 = Task.Factory.StartNew(
    () => Console.WriteLine("Task2 is executed"));

Task task3 = Task.Run(
    () => Console.WriteLine("Task3 is executed"));
    
Console.ReadLine();
```

```
вывод:
Z:/oap/labs/lab5_multithreading/ConsoleApp2/ConsoleApp2/bin/Debug/net8.0/ConsoleApp2.exe
Task1 is executed
Task3 is executed
Task2 is executed

```
## Ожидание...

### 1

```
using System;
using System.Threading;
 
Task task = new Task(Display);
task.Start();
    
Console.WriteLine(
    "Завершение метода Main");

Console.ReadLine();

static void Display()
{
    Console.WriteLine(
        "Начало работы метода Display");

    Console.WriteLine(
        "Завершение работы метода Display");
}
```

```
вывод:
Z:/oap/labs/lab5_multithreading/ConsoleApp2/ConsoleApp2/bin/Debug/net8.0/ConsoleApp2.exe
Начало работы метода Display
Завершение работы метода Display
Завершение метода Main
```

## асинхронные методы, async и await
### 1

```
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        await FactorialAsync();
        Console.WriteLine("Введите число: ");
        int n = Int32.Parse(Console.ReadLine());
        Console.WriteLine($"Квадрат числа равен {n * n}");
        Console.Read();
    }

    static void Factorial()
    {
        int result = 1;
        for (int i = 1; i <= 6; i++)
        {
            result *= i;
        }

        Thread.Sleep(8000);
        Console.WriteLine($"Факториал равен {result}");
    }

    static async Task FactorialAsync()
    {
        Console.WriteLine("Начало метода FactorialAsync");
        await Task.Run(() => Factorial());
        Console.WriteLine("Конец метода FactorialAsync");
    }
}
```

```
вывод:
Z:/oap/labs/lab5_multithreading/ConsoleApp2/ConsoleApp2/bin/Debug/net8.0/ConsoleApp2.exe
Начало метода FactorialAsync
Факториал равен 720
Конец метода FactorialAsync
Введите число:
44
Квадрат числа равен 1936  
```

### 2

```

using System;
using System.Threading;
using System.Threading.Tasks;
using System.IO;
 
ReadWriteAsync();
    
Console.WriteLine("какая-то работа");
Console.Read();


static async void ReadWriteAsync()
{
    string s = "Hello world! One step at a time";


    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);
    }
}

```


```
вывод: 
какая-то работа
Hello world! One step at a time

2

```

## Определение асинхронной операции

### 1

```
StreamWriter writer = new StreamWriter("hello.txt", false);

await writer.WriteLineAsync("Hello");  
```
вывод:
```
Process finished with exit code 0.
```

### 2

```
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()); 
}
```
ывод:
```
Process finished with exit code 0.
```

### 3

```
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Введите число: ");
        int input = Int32.Parse(Console.ReadLine());
        await FactorialAsync(input);
        Console.Read();
    }

    static async Task FactorialAsync(int n)
    {
        Console.WriteLine("Начало метода FactorialAsync");
        await Task.Run(() =>
        {
            int result = 1;
            for (int i = 1; i <= n; i++)
            {
                result *= i;
            }
            Thread.Sleep(8000);
            Console.WriteLine($"Факториал числа {n} равен {result}");
        });
        Console.WriteLine("Конец метода FactorialAsync");
    }
}
```
Вывод:
```
Введите число для вычисления факториала:
6
Начало метода FactorialAsync
Факториал числа 6 равен 720
Конец метода FactorialAsync


```
## передача параметров в асинхронную операцию

### n1

```
using System;
using System.Threading;
using System.Threading.Tasks;
 

FactorialAsync(9);
FactorialAsync(5);
Console.WriteLine("некоторая работа");
Console.Read();


static void Factorial(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    Thread.Sleep(2000);
    Console.WriteLine($"Факториал равен {result}");
}

static async void FactorialAsync(int n)
{
    await Task.Run(()=>Factorial(n));
}
```
### Вывод:
```
некоторая работа
Факториал равен 362880
Факториал равен 120

```

## Получение результата из асинхронной операции

### n1

```
using System;
using System.Threading;
using System.Threading.Tasks;
 

FactorialAsync(5);
FactorialAsync(4);
Console.Read();


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}");
}
```
### Вывод:
```
Факториал равен 24
Факториал равен 120
```

## Возвращение результата из асинхронного метода

### n1 Void

```
static void Factorial(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    Console.WriteLine($"Факториал равен {result}");
}

static async void FactorialAsync(int n)
{
    await Task.Run(()=>Factorial(n));
}
```
### Вывод:
```
Process finished with exit code 0.
```

### n2 Task

```
using System;
using System.Threading.Tasks;

FactorialAsync(6);
FactorialAsync(9);
Console.WriteLine("Некоторая работа");
Console.Read();

static void Factorial(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    Console.WriteLine($"Факториал равен {result}");
}
    

static async Task FactorialAsync(int n)
{
    await Task.Run(()=>Factorial(n));
}
```
### Вывод:
```
Факториал равен 362880
Некоторая работа   
Факториал равен 720
```

### n3 Task (T)

```
using System;
using System.Threading.Tasks;

int n1 = await FactorialAsync(7);
int n2 = await FactorialAsync(9);
Console.WriteLine($"n1={n1}  n2={n2}");
Console.Read();

static int Factorial(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    return result;
}

static async Task<int> FactorialAsync(int n)
{
    return await Task.Run(()=>Factorial(n));
}
```
### Вывод:
```
n1=5040  n2=362880
```
## Последовательный и параллельный вызов асинхронных операций

### n1

```
using System;
using System.Threading.Tasks;

FactorialAsync();
Console.Read();

static void Factorial(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    Console.WriteLine($"Факториал числа {n} равен {result}");
}

static async void FactorialAsync()
{
    await Task.Run(() => Factorial(6));
    await Task.Run(() => Factorial(2));
    await Task.Run(() => Factorial(7));
}
```
### Вывод:
```
Факториал числа 6 равен 720
Факториал числа 2 равен 2
Факториал числа 7 равен 5040

```

## Обработка ошибок в асинхронных методах

### n1

```
using System;
using System.Threading;
using System.Threading.Tasks;
 

FactorialAsync(-1);
FactorialAsync(6);
Console.Read();

static void Factorial(int n)
{
    if (n < 1)
        throw new Exception($"{n} : число не должно быть меньше 1");
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    Console.WriteLine($"Факториал числа {n} равен {result}");
}
    
static async void FactorialAsync(int n)
{
    try
    {
        await Task.Run(() => Factorial(n));
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
```
### Вывод:
```
Факториал числа 6 равен 720
-1 : число не должно быть меньше 1

```

## Отмена асинхронных операций

### n1

```
using System;
using System.Threading;
using System.Threading.Tasks;
 
CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
FactorialAsync(7, token);
Thread.Sleep(2000);
cts.Cancel();
Console.Read();

static void Factorial(int n, CancellationToken token)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        if (token.IsCancellationRequested)
        {
            Console.WriteLine(
                "Операция прервана токеном");
            return;
        }
        result *= i;
        Console.WriteLine(
            $"Факториал числа {i} равен {result}");
        Thread.Sleep(1350);
    }
}

static async void FactorialAsync(int n, CancellationToken token)
{
    if(token.IsCancellationRequested)
        return;
    await Task.Run(()=>Factorial(n, token));
}
```
### Вывод:
```
Факториал числа 1 равен 1
Факториал числа 2 равен 2
Операция прервана токеном
```