бамбуковый баобаб

readme.md

@@ -1,569 +1,736 @@
-# Конспект лекции "Многопоточность" :()=[,`][]=
-### // Задачи и класс Task
-## Первый способ создание объекта Task и вызов у него метода Start:
+# Конспект лекции "Работа с каталогами и файлами"
+## Работа с дисками
 ```
-Task task = new Task(
-    () => Console.WriteLine("Hello Task!")
-);
-task.Start();
+using System;
+using System.IO;
+ 
+DriveInfo[] drives = DriveInfo.GetDrives();
+
+foreach (DriveInfo drive in drives)
+{
+    Console.WriteLine($"Название: {drive.Name}");
+    Console.WriteLine($"Тип: {drive.DriveType}");
+    if (drive.IsReady)
+    {
+        Console.WriteLine($"Объем диска: {drive.TotalSize}");
+        Console.WriteLine($"Свободное пространство: {drive.TotalFreeSpace}");
+        Console.WriteLine($"Метка: {drive.VolumeLabel}");
+    }
+    Console.WriteLine();
+}
 ```
+Результат работы:
 ```
+Название: C:\
+Тип: Fixed                         
+Объем диска: 127326396416          
+Свободное пространство: 81790328832
+Метка:                             
+
+Название: D:\
+Тип: Fixed
+Объем диска: 249375666176
+Свободное пространство: 84100747264
+Метка:
+
 Process finished with exit code 0.
 ```
-## Второй способ заключается в использовании статического метода Task.Factory.StartNew()
-```
-Task task = Task.Factory.StartNew(
-    () => Console.WriteLine("Hello Task!")
-);
+## Работа с каталогами
+### Получение списка файлов и подкаталогов
 ```
+string dirName = "C:\\";
+ 
+if (Directory.Exists(dirName))
+{
+    Console.WriteLine("Подкаталоги:");
+    string[] dirs = Directory.GetDirectories(dirName);
+    foreach (string s in dirs)
+    {
+        Console.WriteLine(s);
+    }
+    Console.WriteLine();
+    Console.WriteLine("Файлы:");
+    string[] files = Directory.GetFiles(dirName);
+    foreach (string s in files)
+    {
+        Console.WriteLine(s);
+    }
+}
 ```
+Результат работы:
+```
+Подкаталоги:
+C:\$Recycle.Bin          
+C:\$WinREAgent           
+C:\Config.Msi            
+C:\Documents and Settings
+C:\Intel                 
+C:\PerfLogs
+C:\Program Files
+C:\Program Files (x86)
+C:\ProgramData
+C:\Recovery
+C:\System Volume Information
+C:\Users
+C:\Windows
+
+Файлы:
+C:\DumpStack.log.tmp
+C:\hiberfil.sys
+C:\pagefile.sys
+C:\swapfile.sys
+
 Process finished with exit code 0.
 ```
-## Третий способ определения и запуска задач представляет использование статического метода Task.Run():
+### Создание каталога
 ```
-Task task = Task.Run(
-    () => Console.WriteLine("Hello Task!")
-);
+string path = @"C:\SomeDir";
+string subpath = @"program\avalon";
+DirectoryInfo dirInfo = new DirectoryInfo(path);
+if (!dirInfo.Exists)
+{
+    dirInfo.Create();
+}
+dirInfo.CreateSubdirectory(subpath);
 ```
+Результат работы:
 ```
 Process finished with exit code 0.
 ```
-## Определим небольшую программу, где используем все эти способы:
+### Получение информации о каталоге
 ```
-using System;
-using System.Threading.Tasks;
+string dirName = "C:\\Program Files";
  
-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();
+DirectoryInfo dirInfo = new DirectoryInfo(dirName);
+ 
+Console.WriteLine($"Название каталога: {dirInfo.Name}");
+Console.WriteLine($"Полное название каталога: {dirInfo.FullName}");
+Console.WriteLine($"Время создания каталога: {dirInfo.CreationTime}");
+Console.WriteLine($"Корневой каталог: {dirInfo.Root}");
 ```
+Результата работы:
 ```
-Task2 is executed
-Task1 is executed
-Task3 is executed
+Название каталога: Program Files
+Полное название каталога: C:\Program Files
+Время создания каталога: 07.12.2019 12:14:52
+Корневой каталог: C:\                       
 
 Process finished with exit code 0.
 ```
-### // Ожидание задачи
-## esempio
+### Удаление каталога
 ```
-using System;
-using System.Threading;
+string dirName = @"C:\SomeFolder";
  
-Task task = new Task(Display);
-task.Start();
-    
-Console.WriteLine(
-    "Завершение метода Main");
-
-Console.ReadLine();
-
-static void Display()
+try
 {
-    Console.WriteLine(
-        "Начало работы метода Display");
-
-    Console.WriteLine(
-        "Завершение работы метода Display");
+    DirectoryInfo dirInfo = new DirectoryInfo(dirName);
+    dirInfo.Delete(true);
+    Console.WriteLine("Каталог удален");
+}
+catch (Exception ex)
+{
+    Console.WriteLine(ex.Message);
 }
 ```
+Результат работы:
 ```
-Завершение метода Main
-Начало работы метода Display    
-Завершение работы метода Display
+Could not find a part of the path 'C:\SomeFolder'.
 
 Process finished with exit code 0.
 ```
-### // Aсинхронное программирование. Асинхронные методы, async и await
-## пример асинхронного метода:
+### Перемещение каталога
 ```
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-// вызов асинхронного метода 
-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 void FactorialAsync()
+string oldPath = @"C:\SomeFolder";
+string newPath = @"C:\SomeDir";
+DirectoryInfo dirInfo = new DirectoryInfo(oldPath);
+if (dirInfo.Exists && Directory.Exists(newPath) == false)
 {
-    // выполняется синхронно
-    Console.WriteLine(
-        "Начало метода FactorialAsync");
-
-    // выполняется асинхронно     
-    await Task.Run(()=>Factorial());
-
-    Console.WriteLine(
-        "Конец метода FactorialAsync");
+    dirInfo.MoveTo(newPath);
 }
 ```
+Результат работы:
 ```
-Начало метода FactorialAsync
-Введите число: 
-7
-Квадрат числа равен 49
-Факториал равен 720
-Конец метода FactorialAsync
-
 Process finished with exit code 0.
 ```
-## esempio - чтение-запись файла:
+## Работа с файлами. Классы File и FileInfo
+### Получение информации о файле
 ```
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using System.IO;
- 
-ReadWriteAsync();
-    
-Console.WriteLine("Некоторая работа");
-Console.Read();
-
-
-static async void ReadWriteAsync()
+string path = @"C:\apache\hta.txt";
+FileInfo fileInf = new FileInfo(path);
+if (fileInf.Exists)
 {
-    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);
-    }
-} 
+    Console.WriteLine("Имя файла: {0}", fileInf.Name);
+    Console.WriteLine("Время создания: {0}", fileInf.CreationTime);
+    Console.WriteLine("Размер: {0}", fileInf.Length);
+}
 ```
+Результат работы:
 ```
-Некоторая работа
-Hello world! One step at a time
-
 Process finished with exit code 0.
 ```
-## мы сами можем определить асинхронную операцию, используя метод Task.Run():
+### Удаление файла
 ```
-static void Factorial()
+string path = @"C:\apache\hta.txt";
+FileInfo fileInf = new FileInfo(path);
+if (fileInf.Exists)
 {
-    int result = 1;
-    for (int i = 1; i <= 6; i++)
-    {
-        result *= i;
-    }
-    Thread.Sleep(8000);
-    Console.WriteLine($"Факториал равен {result}");
+   fileInf.Delete();
+   // альтернатива с помощью класса File
+   // File.Delete(path);
 }
-// определение асинхронного метода
-static async void FactorialAsync()
+```
+Результат работы:
+```
+Process finished with exit code 0.
+```
+### Перемещение файла
+```
+string path = @"C:\apache\hta.txt";
+string newPath = @"C:\SomeDir\hta.txt";
+FileInfo fileInf = new FileInfo(path);
+if (fileInf.Exists)
 {
-    // вызов асинхронной операции
-    await Task.Run(()=>Factorial()); 
+   fileInf.MoveTo(newPath);       
+   // альтернатива с помощью класса File
+   // File.Move(path, newPath);
 }
 ```
+Результат работы:
 ```
 Process finished with exit code 0.
 ```
-## Можно определить асинхронную операцию с помощью лямбда-выражения:
+### Копирование файла
 ```
-static async void FactorialAsync()
+string path = @"C:\apache\hta.txt";
+string newPath = @"C:\SomeDir\hta.txt";
+FileInfo fileInf = new FileInfo(path);
+if (fileInf.Exists)
 {
-    await Task.Run(() =>
-    {
-        int result = 1;
-        for (int i = 1; i <= 6; i++)
-        {
-            result *= i;
-        }
-        Thread.Sleep(8000);
-        Console.WriteLine($"Факториал равен {result}");
-    });
+   fileInf.CopyTo(newPath, true);      
+   // альтернатива с помощью класса File
+   // File.Copy(path, newPath, true);
 }
 ```
+Результат работы:
 ```
 Process finished with exit code 0.
 ```
-### // Передача параметров в асинхронную операцию
-## мы хотим вычислить факториалы разных чисел:
+## FileStream. Чтение и запись файла
+### Посмотрим на примере считывания-записи в текстовый файл:
 ```
 using System;
-using System.Threading;
-using System.Threading.Tasks;
+using System.IO;
  
-
-FactorialAsync(5);
-FactorialAsync(6);
-Console.WriteLine("Некоторая работа");
-Console.Read();
-
-
-static void Factorial(int n)
+namespace HelloApp
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    class Program
     {
-        result *= i;
+        static void Main(string[] args)
+        {
+            // создаем каталог для файла
+            string path = @"C:\Users\mister pig\Documents\panda";
+            DirectoryInfo dirInfo = new DirectoryInfo(path);
+            if (!dirInfo.Exists)
+            {
+                dirInfo.Create();
+            }
+            Console.WriteLine("Введите строку для записи в файл:");
+            string text = Console.ReadLine();
+ 
+            // запись в файл
+            using (FileStream fstream = new FileStream($"{path}\note.txt", FileMode.OpenOrCreate))
+            {
+                // преобразуем строку в байты
+                byte[] array = System.Text.Encoding.Default.GetBytes(text);
+                // запись массива байтов в файл
+                fstream.Write(array, 0, array.Length);
+                Console.WriteLine("Текст записан в файл");
+            }
+ 
+            // чтение из файла
+            using (FileStream fstream = File.OpenRead($"{path}\note.txt"))
+            {
+                // преобразуем строку в байты
+                byte[] array = new byte[fstream.Length];
+                // считываем данные
+                fstream.Read(array, 0, array.Length);
+                // декодируем байты в строку
+                string textFromFile = System.Text.Encoding.Default.GetString(array);
+                Console.WriteLine($"Текст из файла: {textFromFile}");
+            }
+ 
+            Console.ReadLine();
+        }
     }
-    Thread.Sleep(5000);
-    Console.WriteLine($"Факториал равен {result}");
-}
-// определение асинхронного метода
-static async void FactorialAsync(int n)
-{
-    await Task.Run(()=>Factorial(n));
 }
 ```
+Результат работы:
 ```
-Некоторая работа
-Факториал равен 120
-Факториал равен 720
+Введите строку для записи в файл:
+panda
+Unhandled exception. System.IO.IOException: Синтаксическая ошибка в имени файла, имени папки или метке тома. : 'C:\Users\mister pig\Documents\panda       
+ote.txt'
+   at Microsoft.Win32.SafeHandles.SafeFileHandle.CreateFile(String fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options)      
+   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 preal
+locationSize)
+   at System.IO.Strategies.OSFileStreamStrategy..ctor(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 prealloca
+tionSize)
+   at System.IO.Strategies.FileStreamHelpers.ChooseStrategyCore(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64
+ preallocationSize)
+   at System.IO.Strategies.FileStreamHelpers.ChooseStrategy(FileStream fileStream, String path, FileMode mode, FileAccess access, FileShare share, Int32 b
+ufferSize, FileOptions options, Int64 preallocationSize)
+   at System.IO.FileStream..ctor(String path, FileMode mode)
+   at HelloApp.Program.Main(String[] args) in C:\Users\mister pig\RiderProjects\bamboo\bamboo\Program.cs:line 21
 
-Process finished with exit code 0.
+Process finished with exit code -532,462,766.
 ```
-### // Получение результата из асинхронной операции
+## изменим выше приведенную программу, применив асинхронные методы:
 ```
 using System;
-using System.Threading;
+using System.IO;
 using System.Threading.Tasks;
  
-
-FactorialAsync(5);
-FactorialAsync(6);
-Console.Read();
-
-
-static int Factorial(int n)
+namespace HelloApp
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    class Program
     {
-        result *= i;
+        static async Task Main(string[] args)
+        {
+            // создаем каталог для файла
+            string path = @"C:\Users\mister pig\Documents\panda";
+            DirectoryInfo dirInfo = new DirectoryInfo(path);
+            if (!dirInfo.Exists)
+            {
+                dirInfo.Create();
+            }
+            Console.WriteLine("Введите строку для записи в файл:");
+            string text = Console.ReadLine();
+ 
+            // запись в файл
+            using (FileStream fstream = new FileStream($"{path}\note.txt", FileMode.OpenOrCreate))
+            {
+                byte[] array = System.Text.Encoding.Default.GetBytes(text);
+                // асинхронная запись массива байтов в файл
+                await fstream.WriteAsync(array, 0, array.Length);
+                Console.WriteLine("Текст записан в файл");
+            }
+ 
+            // чтение из файла
+            using (FileStream fstream = File.OpenRead($"{path}\note.txt"))
+            {
+                byte[] array = new byte[fstream.Length];
+                // асинхронное чтение файла
+                await fstream.ReadAsync(array, 0, array.Length);
+ 
+                string textFromFile = System.Text.Encoding.Default.GetString(array);
+                Console.WriteLine($"Текст из файла: {textFromFile}");
+            }
+ 
+            Console.ReadLine();
+        }
     }
-    return result;
 }
-// определение асинхронного метода
-static async void FactorialAsync(int n)
+```
+Результат работы:
+```
+Введите строку для записи в файл:
+panda
+Unhandled exception. System.IO.IOException: Синтаксическая ошибка в имени файла, имени папки или метке тома. : 'C:\Users\mister pig\Documents\panda       
+ote.txt'
+   at Microsoft.Win32.SafeHandles.SafeFileHandle.CreateFile(String fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options)      
+   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 preal
+locationSize)
+   at System.IO.Strategies.OSFileStreamStrategy..ctor(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 prealloca
+tionSize)
+   at System.IO.Strategies.FileStreamHelpers.ChooseStrategyCore(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64
+ preallocationSize)
+   at System.IO.Strategies.FileStreamHelpers.ChooseStrategy(FileStream fileStream, String path, FileMode mode, FileAccess access, FileShare share, Int32 b
+ufferSize, FileOptions options, Int64 preallocationSize)
+   at System.IO.FileStream..ctor(String path, FileMode mode)
+   at HelloApp.Program.Main(String[] args) in C:\Users\mister pig\RiderProjects\bamboo\bamboo\Program.cs:line 22
+   at HelloApp.Program.<Main>(String[] args)
+
+Process finished with exit code -532,462,766.
+```
+### Произвольный доступ к файлам
+```
+using System.IO;
+using System.Text;
+ 
+class Program
 {
-    int x = await Task.Run(()=>Factorial(n));
-    Console.WriteLine($"Факториал равен {x}");
+    static void Main(string[] args)
+    {
+        string text = "hello world";
+             
+        // запись в файл
+        using (FileStream fstream = new FileStream(@"C:\Users\mister pig\Documents\panda\panda.txt", FileMode.OpenOrCreate))
+        {
+            // преобразуем строку в байты
+            byte[] input = Encoding.Default.GetBytes(text);
+            // запись массива байтов в файл
+            fstream.Write(input, 0, input.Length);
+            Console.WriteLine("Текст записан в файл");
+ 
+            // перемещаем указатель в конец файла, до конца файла- пять байт
+            fstream.Seek(-5, SeekOrigin.End); // минус 5 символов с конца потока
+ 
+            // считываем четыре символов с текущей позиции
+            byte[] output = new byte[4];
+            fstream.Read(output, 0, output.Length);
+            // декодируем байты в строку
+            string textFromFile = Encoding.Default.GetString(output);
+            Console.WriteLine($"Текст из файла: {textFromFile}"); // worl
+ 
+            // заменим в файле слово world на слово house
+            string replaceText = "house";
+            fstream.Seek(-5, SeekOrigin.End); // минус 5 символов с конца потока
+            input = Encoding.Default.GetBytes(replaceText);
+            fstream.Write(input, 0, input.Length);
+ 
+            // считываем весь файл
+            // возвращаем указатель в начало файла
+            fstream.Seek(0, SeekOrigin.Begin);
+            output = new byte[fstream.Length];
+            fstream.Read(output, 0, output.Length);
+            // декодируем байты в строку
+            textFromFile = Encoding.Default.GetString(output);
+            Console.WriteLine($"Текст из файла: {textFromFile}"); // hello house
+        }
+        Console.Read();
+    }
 }
 ```
+Результат работы:
 ```
-Факториал равен 120
-Факториал равен 720
+Текст записан в файл
+Текст из файла: worl       
+Текст из файла: hello house
 
 Process finished with exit code 0.
 ```
-### // Возвращение результата из асинхронного метода
-## void
+### Закрытие потока
 ```
-static void Factorial(int n)
+FileStream fstream = null;
+try
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
-    {
-        result *= i;
-    }
-    Console.WriteLine($"Факториал равен {result}");
+    fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate);
+    // операции с потоком
+}
+catch(Exception ex)
+{
+ 
 }
-// определение асинхронного метода
-static async void FactorialAsync(int n)
+finally
 {
-    await Task.Run(()=>Factorial(n));
+    if (fstream != null)
+        fstream.Close();
 }
 ```
+Результат работы:
 ```
 Process finished with exit code 0.
 ```
-## Task
+## Чтение и запись текстовых файлов. StreamReader и StreamWriter
+### запись в файл
 ```
 using System;
-using System.Threading.Tasks;
-
-FactorialAsync(5);
-FactorialAsync(6);
-Console.WriteLine("Некоторая работа");
-Console.Read();
-
-static void Factorial(int n)
+using System.IO;
+ 
+namespace HelloApp
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    class Program
     {
-        result *= i;
+        static void Main(string[] args)
+        {
+            string writePath = @"C:\SomeDir\hta.txt";
+ 
+            string text = "Привет мир!\nПока мир...";
+            try
+            {
+                using (StreamWriter sw = new StreamWriter(
+                    writePath, false, System.Text.Encoding.Default))
+                {
+                    sw.WriteLine(text);
+                }
+ 
+                using (StreamWriter sw = new StreamWriter(
+                    writePath, true, System.Text.Encoding.Default))
+                {
+                    sw.WriteLine("Дозапись");
+                    sw.Write(4.5);
+                }
+                Console.WriteLine("Запись выполнена");
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+        }
     }
-    Console.WriteLine($"Факториал равен {result}");
-}
-    
-// определение асинхронного метода
-static async Task FactorialAsync(int n)
-{
-    await Task.Run(()=>Factorial(n));
 }
 ```
+Результат работы:
 ```
-Факториал равен 120
-Факториал равен 720
-Некоторая работа  
+Запись выполнена
 
 Process finished with exit code 0.
 ```
-## Task<T>
+### асинхронные версии методов:
 ```
 using System;
+using System.IO;
 using System.Threading.Tasks;
-
-int n1 = await FactorialAsync(5);
-int n2 = await FactorialAsync(6);
-Console.WriteLine($"n1={n1}  n2={n2}");
-Console.Read();
-
-static int Factorial(int n)
+ 
+namespace HelloApp
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    class Program
     {
-        result *= i;
+        static async Task Main(string[] args)
+        {
+            string writePath = @"C:\SomeDir\hta2.txt";
+ 
+            string text = "Привет мир!\nПока мир...";
+            try
+            {
+                using (StreamWriter sw = new StreamWriter(
+                    writePath, false, System.Text.Encoding.Default))
+                {
+                    await sw.WriteLineAsync(text);
+                }
+ 
+                using (StreamWriter sw = new StreamWriter(
+                    writePath, true, System.Text.Encoding.Default))
+                {
+                    await sw.WriteLineAsync("Дозапись");
+                    await sw.WriteAsync("4,5");
+                }
+                Console.WriteLine("Запись выполнена");
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+        }
     }
-    return result;
-}
-// определение асинхронного метода
-static async Task<int> FactorialAsync(int n)
-{
-    return await Task.Run(()=>Factorial(n));
 }
 ```
+Результат работы:
 ```
-n1=120  n2=720
+Запись выполнена
 
 Process finished with exit code 0.
 ```
-### // Последовательный и параллельный вызов асинхронных операций
+### Сначала считаем текст полностью из ранее записанного файла:
 ```
 using System;
+using System.IO;
 using System.Threading.Tasks;
+ 
+string path = @"C:\SomeDir\hta.txt";
 
-FactorialAsync();
-Console.Read();
-
-static void Factorial(int n)
+try
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    using (StreamReader sr = new StreamReader(path))
     {
-        result *= i;
+        Console.WriteLine(sr.ReadToEnd());
+    }
+    // асинхронное чтение
+    using (StreamReader sr = new StreamReader(path))
+    {
+        Console.WriteLine(await sr.ReadToEndAsync());
     }
-    Console.WriteLine($"Факториал числа {n} равен {result}");
 }
-// определение асинхронного метода
-static async void FactorialAsync()
+catch (Exception e)
 {
-    await Task.Run(() => Factorial(4));
-    await Task.Run(() => Factorial(3));
-    await Task.Run(() => Factorial(5));
+    Console.WriteLine(e.Message);
 }
 ```
+Результат работы:
 ```
-Факториал числа 4 равен 24
-Факториал числа 3 равен 6  
-Факториал числа 5 равен 120
+Привет мир!
+Пока мир...
+Дозапись   
+4,5        
+Привет мир!
+Пока мир...
+Дозапись
+4,5
 
 Process finished with exit code 0.
 ```
-### // Обработка ошибок в асинхронных методах
-## Обработка ошибок в асинхронных методах, использующих ключевые слова async и await, имеет свои особенности.
+### Считаем текст из файла построчно:
 ```
-using System;
-using System.Threading;
-using System.Threading.Tasks;
- 
-
-FactorialAsync(-4);
-FactorialAsync(6);
-Console.Read();
-
-static void Factorial(int n)
+string path= @"C:\SomeDir\hta.txt";
+   
+using (StreamReader sr = new StreamReader(path, System.Text.Encoding.Default))
 {
-    if (n < 1)
-        throw new Exception($"{n} : число не должно быть меньше 1");
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    string line;
+    while ((line = sr.ReadLine()) != null)
     {
-        result *= i;
+        Console.WriteLine(line);
     }
-    Console.WriteLine($"Факториал числа {n} равен {result}");
 }
-    
-static async void FactorialAsync(int n)
+// асинхронное чтение
+using (StreamReader sr = new StreamReader(path, System.Text.Encoding.Default))
 {
-    try
-    {
-        await Task.Run(() => Factorial(n));
-    }
-    catch (Exception ex)
+    string line;
+    while ((line = await sr.ReadLineAsync()) != null)
     {
-        Console.WriteLine(ex.Message);
+        Console.WriteLine(line);
     }
 }
 ```
+Результат работы:
 ```
-Факториал числа 6 равен 720
--4 : число не должно быть меньше 1
+Привет мир!
+Пока мир...
+Дозапись   
+4,5        
+Привет мир!
+Пока мир...
+Дозапись
+4,5
 
 Process finished with exit code 0.
 ```
-## поломанный код
+## Бинарные файлы. BinaryWriter и BinaryReader
 ```
-static async void FactorialAsync(int n)
+struct State
 {
-    Task task = null;
-    try
-    {
-        task = Task.Run(()=>Factorial(n));
-        await task;
-    }
-    catch (Exception ex)
+    public string name;
+    public string capital;
+    public int area;
+    public double people;
+ 
+    public State(string n, string c, int a, double p)
     {
-        Console.WriteLine(task.Exception.InnerException.Message);
-        Console.WriteLine($"IsFaulted: {task.IsFaulted}");
+        name = n;
+        capital = c;
+        people = p;
+        area = a;
     }
 }
-```
-```
-error
-```
-## эксепшен не эксепшен, вывод с неба упал
-```
-static async Task DoMultipleAsync()
+class Program
 {
-    Task allTasks = null;
- 
-    try
+    static void Main(string[] args)
     {
-        Task t1 = Task.Run(()=>Factorial(-3));
-        Task t2 = Task.Run(() => Factorial(-5));
-        Task t3 = Task.Run(() => Factorial(-10));
+        State[] states = new State[2];
+        states[0] = new State("Германия", "Берлин",  357168,  80.8);
+        states[1] = new State("Франция", "Париж", 640679, 64.7);
  
-        allTasks = Task.WhenAll(t1, t2, t3);
-        await allTasks;
-    }
-    catch (Exception ex)
-    {
-        Console.WriteLine("Исключение: " + ex.Message);
-        Console.WriteLine("IsFaulted: " + allTasks.IsFaulted);
-        foreach (var inx in allTasks.Exception.InnerExceptions)
+        string path= @"C:\SomeDir\states.dat";
+ 
+        try
         {
-            Console.WriteLine("Внутреннее исключение: " + inx.Message);
+            // создаем объект BinaryWriter
+            using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.OpenOrCreate)))
+            {
+                // записываем в файл значение каждого поля структуры
+                foreach (State s in states)
+                {
+                    writer.Write(s.name);
+                    writer.Write(s.capital);
+                    writer.Write(s.area);
+                    writer.Write(s.people);
+                }
+            }
+            // создаем объект BinaryReader
+            using (BinaryReader reader = new BinaryReader(File.Open(path, FileMode.Open)))
+            {
+                // пока не достигнут конец файла
+                // считываем каждое значение из файла
+                while (reader.PeekChar() > -1)
+                {
+                    string name = reader.ReadString();
+                    string capital = reader.ReadString();
+                    int area = reader.ReadInt32();
+                    double population = reader.ReadDouble();
+ 
+                    Console.WriteLine("Страна: {0}  столица: {1}  площадь {2} кв. км   численность населения: {3} млн. чел.", 
+                        name, capital, area, population);
+                }
+            }
         }
+        catch (Exception e)
+        {
+            Console.WriteLine(e.Message);
+        }
+        Console.ReadLine();
     }
 }
 ```
+Результат работы:
 ```
-Исключение: -3 : число не должно быть меньше 1
-IsFaulted: True
-Внутреннее исключение: -3: число не должно быть меньше 1
-Внутреннее исключение: -5: число не должно быть меньше 1
-Внутреннее исключение: -10: число не должно быть меньше 1
-```
-## никакой возможности нет, это афера
-```
-static async void FactorialAsync(int n)
-{
-    try
-    {
-        await Task.Run(() => Factorial(n)); ;
-    }
-    catch (Exception ex)
-    {
-        await Task.Run(()=>Console.WriteLine(ex.Message));
-    }
-    finally
-    {
-        await Task.Run(() => Console.WriteLine("await в блоке finally"));
-    }
-}
-```
-```
-error
+Страна: Германия  столица: Берлин  площадь 357168 кв. км   численность населения: 80,8 млн. чел.
+Страна: Франция  столица: Париж  площадь 640679 кв. км   численность населения: 64,7 млн. чел.
+
+Process finished with exit code 0.
 ```
-### // Отмена асинхронных операций
+## Бинарная сериализация. BinaryFormatter
 ```
 using System;
-using System.Threading;
-using System.Threading.Tasks;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
  
-CancellationTokenSource cts = new CancellationTokenSource();
-CancellationToken token = cts.Token;
-FactorialAsync(6, token);
-Thread.Sleep(3000);
-cts.Cancel();
-Console.Read();
-
-static void Factorial(int n, CancellationToken token)
+namespace Serialization
 {
-    int result = 1;
-    for (int i = 1; i <= n; i++)
+    [Serializable]
+    class Person
     {
-        if (token.IsCancellationRequested)
+        public string Name { get; set; }
+        public int Age { get; set; }
+ 
+        public Person(string name, int age)
         {
-            Console.WriteLine(
-                "Операция прервана токеном");
-            return;
+            Name = name;
+            Age = age;
+        }
+    }
+     
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            // объект для сериализации
+            Person person = new Person("Tom", 29);
+            Console.WriteLine("Объект создан");
+ 
+            // создаем объект BinaryFormatter
+            BinaryFormatter formatter = new BinaryFormatter();
+            // получаем поток, куда будем записывать сериализованный объект
+            using (FileStream fs = new FileStream("people.dat", FileMode.OpenOrCreate))
+            {
+                formatter.Serialize(fs, person);
+ 
+                Console.WriteLine("Объект сериализован");
+            }
+ 
+            // десериализация из файла people.dat
+            using (FileStream fs = new FileStream("people.dat", FileMode.OpenOrCreate))
+            {
+                Person newPerson = (Person)formatter.Deserialize(fs);
+ 
+                Console.WriteLine("Объект десериализован");
+                Console.WriteLine($"Имя: {newPerson.Name} --- Возраст: {newPerson.Age}");
+            }
+ 
+            Console.ReadLine();
         }
-        result *= i;
-        Console.WriteLine(
-            $"Факториал числа {i} равен {result}");
-        Thread.Sleep(1000);
     }
-}
-// определение асинхронного метода
-static async void FactorialAsync(int n, CancellationToken token)
-{
-    if(token.IsCancellationRequested)
-        return;
-    await Task.Run(()=>Factorial(n, token));
 }
 ```
+Результат работы:
 ```
-Факториал числа 1 равен 1
-Факториал числа 2 равен 2
-Факториал числа 3 равен 6
-Операция прервана токеном
-
-Process finished with exit code 0.
+Объект создан
+Объект сериализован
+Объект десериализован   
+Имя: Tom --- Возраст: 29
 ```
 
+
+
+
+
+
+