## работа с дисками
### pervoe zadanie
```
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();
}
```
### вывод:
```
название: Z:\                       
тип: Fixed                          
объем диска: 512107737088           
свободное пространство: 107316289536
метка: ssdeha 
```
## работа с каталогами

### получение списка файлов и подкаталогов

```
string dirName = "Z:\\";
 
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);
    }
}
```
### вывод:
```
подкаталоги:
Z:\$RECYCLE.BIN             
Z:\FL                       
Z:\govno                    
Z:\JetBrains Rider 2023.3.3 
Z:\krasivie_niggers         
Z:\oap                      
Z:\SteamLibrary             
Z:\System Volume Information
Z:\The Jackbox Party Pack 6 
                            
файлы:                      
Z:\passwords,codes.txt   
```

### cоздание каталога

```
string path = @"Z:\SomeDir";
string subpath = @"program\avalon";
DirectoryInfo dirInfo = new DirectoryInfo(path);
if (!dirInfo.Exists)
{
    dirInfo.Create();
}
dirInfo.CreateSubdirectory(subpath);
```
### вывод:
```
Process finished with exit code 0.
```

### получение информации о каталоге

```
string dirName = "Z:\\oap";
 
DirectoryInfo dirInfo = new DirectoryInfo(dirName);
 
Console.WriteLine($"название каталога: {dirInfo.Name}");
Console.WriteLine($"полное название каталога: {dirInfo.FullName}");
Console.WriteLine($"время создания каталога: {dirInfo.CreationTime}");
Console.WriteLine($"корневой каталог: {dirInfo.Root}");
```
### вывод:
```
название каталога: oap
полное название каталога: Z:\oap
время создания каталога: 11.02.2024 13:10:13
корневой каталог: Z:\  
```

### y даление каталога

```
string dirName = @"C:\SomeFolder";
 
try
{
    DirectoryInfo dirInfo = new DirectoryInfo(dirName);
    dirInfo.Delete(true);
    Console.WriteLine("каталог удален");
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}
```

```
Could not find a part of the path 'C:\SomeFolder'.

Process finished with exit code 0.
```

### перемещение каталога

```
string oldPath = @"Z:\SomeFolder";
string newPath = @"Z:\SomeDir";
DirectoryInfo dirInfo = new DirectoryInfo(oldPath);
if (dirInfo.Exists && Directory.Exists(newPath) == false)
{
    dirInfo.MoveTo(newPath);
}
```
### вывод:
```
Process finished with exit code 0.
```


## работа с файлами. классы File и FileInfo

### получение информации о файле

```
string path = @"F:\owner\msvcp120.dll";
FileInfo fileInf = new FileInfo(path);
if (fileInf.Exists)
{
    Console.WriteLine("имя файла: {0}", fileInf.Name);
    Console.WriteLine("время создания: {0}", fileInf.CreationTime);
    Console.WriteLine("размер: {0}", fileInf.Length);
}
```
### вывод:
```
имя файла: msvcp120.dll
время создания: 20.11.2019 19:11:50
размер: 455328   
```

### удаление файла

```
string path = @"Z:\owner\msvcp120.dll";
FileInfo fileInf = new FileInfo(path);
if (fileInf.Exists)
{
   fileInf.Delete();
}
```
### вывод:
```
Process finished with exit code 0.
```

### перемещение файла

```
string path = @"Z:\owner\msvcp120.dll";
string newPath = @"Z:\SomeDir\fortask.txt";
FileInfo fileInf = new FileInfo(path);
if (fileInf.Exists)
{
   fileInf.MoveTo(newPath);       
}
```
### вывод:
```
Process finished with exit code 0.
```


### копирование файла

```
string path = @"Z:\owner\msvcp120.dll";
string newPath = @"Z:\SomeDir\msvcp120.dll";
FileInfo fileInf = new FileInfo(path);
if (fileInf.Exists)
{
   fileInf.CopyTo(newPath, true);      
}
```
### вывод:
```
Process finished with exit code 0.
```

## FileStream. чтение и запись файла

### Ччение и запись файлов

```
using System;
using System.IO;
 
namespace HelloApp
{
    class Program
    {
        static void Main(string[] args)
        {
            string path = @"Z:\SomeDir2";
            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();
        }
    }
}
```
### вывод:
```
введите строку для записи в файл:
я люблю прогать
Unhandled exception. System.IO.IOException: Синтаксическая ошибка в имени файла, имени папки или метке тома. : 'Z:\SomeDir2
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
 preallocationSize, Nullable`1 unixCreateMode)
   at System.IO.Strategies.OSFileStreamStrategy..ctor(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 pre
allocationSize, Nullable`1 unixCreateMode)
   at System.IO.Strategies.FileStreamHelpers.ChooseStrategyCore(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options,
 Int64 preallocationSize, Nullable`1 unixCreateMode)
   at System.IO.FileStream..ctor(String path, FileMode mode)
   at HelloApp.Program.Main(String[] args) in Z:\oap\labs\t5_files\ConsoleApp1\ConsoleApp1\Program.cs:line 19
```
### произвольный доступ к файлам

```
using System.IO;
using System.Text;
 
class Program
{
    static void Main(string[] args)
    {
        string text = "hello world";
             
          
        using (FileStream fstream = new FileStream(@"Z:\note.dat", FileMode.OpenOrCreate))
        {

            byte[] input = Encoding.Default.GetBytes(text);

            fstream.Write(input, 0, input.Length);
            Console.WriteLine("текст записан в файл");
 

            fstream.Seek(-5, SeekOrigin.End);
 

            byte[] output = new byte[5];
            fstream.Read(output, 0, output.Length);

            string textFromFile = Encoding.Default.GetString(output);
            Console.WriteLine($"Текст из файла: {textFromFile}"); 
 
            // заменим в файле слово world на слово house
            string replaceText = "house";
            fstream.Seek(-5, SeekOrigin.End); 
            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}"); 
        }
        Console.Read();
    }
}
```
### вывод:
```
текст записан в файл
Текст из файла: world
текст из файла: hello house
```

### Закрытие потока

```
FileStream fstream = null;
try
{
    fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate);
    // операции с потоком
}
catch(Exception ex)
{
 
}
finally
{
    if (fstream != null)
        fstream.Close();
}
```
### вывод:
```
Process finished with exit code 0.
```

### чтение и запись текстовых файлов. StreamReader и StreamWriter

```
using System;
using System.IO;
 
namespace HelloApp
{
    class Program
    {
        static void Main(string[] args)
        {
            string writePath = @"Z:\SomeDir\text.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);
            }
        }
    }
}   
```
### вывод:
```
запись выполнена
```

```
using System;
using System.IO;
using System.Threading.Tasks;
 
namespace HelloApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            string writePath = @"Z:\SomeDir\text.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);
            }
        }
    }
}
```
### вывод:
```
запись выполнена

Process finished with exit code 0.
```

### чтение из файла и StreamReader

```
using System;
using System.IO;
using System.Threading.Tasks;
 
string path = @"Z:\SomeDir\text.txt";

try
{
    using (StreamReader sr = new StreamReader(path))
    {
        Console.WriteLine(sr.ReadToEnd());
    }

    using (StreamReader sr = new StreamReader(path))
    {
        Console.WriteLine(await sr.ReadToEndAsync());
    }
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
}
```
### вывод:
```
привет мир!
пока мир...
дозапись   
4,5        
привет мир!
пока мир...
дозапись   
4,5  
```
```
string path= @"Z:\SomeDir\text.txt";
   
using (StreamReader sr = new StreamReader(path, System.Text.Encoding.Default))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
        Console.WriteLine(line);
    }
}

using (StreamReader sr = new StreamReader(path, System.Text.Encoding.Default))
{
    string line;
    while ((line = await sr.ReadLineAsync()) != null)
    {
        Console.WriteLine(line);
    }
}
```
### вывод:
```
привет мир!
пока мир...
дозапись   
4,5        
привет мир!
пока мир...
дозапись   
4,5    
```

## бинарные файлы. BinaryWriter и BinaryReader

```
struct State
{
    public string name;
    public string capital;
    public int area;
    public double people;
 
    public State(string n, string c, int a, double p)
    {
        name = n;
        capital = c;
        people = p;
        area = a;
    }
}
class Program
{
    static void Main(string[] args)
    {
        State[] states = new State[2];
        states[0] = new State("Германия", "Берлин",  357168,  80.8);
        states[1] = new State("Франция", "Париж", 640679, 64.7);
 
        string path= @"Z:\SomeDir\states.dat";
 
        try
        {

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

            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();
    }
}
```
### вывод:
```
страна: Германия  столица: Берлин  площадь 357168 кв. км   численность населения: 80,8 млн. чел.
страна: Франция  столица: Париж  площадь 640679 кв. км   численность населения: 64,7 млн. чел.
```