# C\#

## Project file

Project file - файл для конфигурации проекта в формате xml

Поля:

* OutputType (Exe | Dll) - во что компилировать
* TargetFramework (net7.0) - версия .NET

## Переменные

```C#
string name = "Tom";
string name2;
name2 = "Bob";
```

## Константы

```C#
const string NAME = "Tom";
```

## Типы данных

* bool
* sbyte (signed byte)
* byte
* short - 16 байт
* ushort (unsigned)
* int - 32 байта
* uint
* long - 64 байта
* ulong
* char - 16 байт. Знак unicode
* float 32 байт
* double - 64 байта
* decimal - 128 бит
* string
* object - аля Python Object

Числа в формате 3.14 по умолчанию double. Если нужен float или decimal, то используются суффиксы

```C#
float a = 3.14f;
decimal b = 3.14m;
```

Для целочисленных по умолчанию int

```C#
int a = 5;
uint b = 5u;
long c = 5l;
ulong d = 5ul;
```

## Неявная типизация

```C#
var hello = "Hello world";
```

Для var объявление и инициализация должны идти вместе

```C#
// Так низя: ошибка
var c;
c = 5;
```

## Вывод в терминал

```C#
Console.WriteLine("Привет");
Console.Write("Привет ");
Console.Write("Мир");
```

Выведет:

```text
Привет
Привет мир
```

## Форматированный вывод

```C#
string name = "John";
string age = 34;
Console.WriteLine($"{name} is {age} years old")
```

## Ввод данных

```C#
string? name = Console.ReadLine();
int foo = Convert.ToInt32(Console.ReadLine());
```

## Простые операторы

* \+
* \-
* \*
* /
* %

## Преобразование базовых типов данных

Операция сложения и вычитания возвращает int, если типы, на которые применяется операция, <= int (byte, short, int)

### Неявное преобразование

Работает только на расширение

```C#
byte a = 4;
ushort = a;
```

### Явное преобразовывание

Работает на расширение и на сужение

```C#
byte a = 5;
byte b = 4;
byte c = (byte) (a+b);
```

## Ветвление

```C#
int a = 5;

if (a == 5) {
    Console.WriteLine("It works");
} else {
    Console.WriteLine("Cosmic ray!");
}
```

### Тернарный оператор

Краткая возвращающая форма if

```C#
int x = 3;
int y = 5;

string z = x < y ? "Works" : "Cosmic ray";
```

### Switch

```C#
int number = 1;

switch (number) {
    case 1:
        Console.WriteLine("case 1");
        goto case 5;
    case 3:
        Console.WriteLine("case 3");
        break;
    case 5:
        Console.WriteLine("case 5");
        break;
    default:
        Console.WriteLine("case whatever");
        break;
}
```

### Циклы

Всё как в С++

* while
* do-while
* for
* foreach

## Массивы

Массивы позволяют хранить заранее известное кол-во элементов вместе

### Инициализация массивов

```C#
int[] a = new int[3] {10, 20, 30};
double[] b = new double[5];
float[] c = {1.5f, 2.3f}; // Поймёт, что нужна длина 2
```

### Длинна массивов

```C#
int[] a = {10, 20};
int len = a.Length;
```

### Методы

```C#
int[] a = {10, 30, 20};

Array.IndexOf(a, 10) // Вернёт 0. -1, если не найдёт.
Array.Sort(a); // Сортирует по возрастанию. Станет {10, 20, 30}
```

### Двумерный массив

```C#
int[,] a = new int[10,10];
```

### Динамический массив

```C#
using System.Collections.Generic;

List<string> words = new List<string> ();
words.Add("Foo");
words.Add("Bar");
words.RemoveAt(1);
```

## Random

```C#
Random r = new Random();
int a = r.Next(); // От 0 до 2 миллиардов
int b = r.Next(5); // От 0 до 5 (не включительно)
int c = r.Next(3, 5); // От 3 до 5
```

## Функции

```C#
void Foo() {
    Console.WriteLine("Hello");
}

// Краткая форма
void Bar() => Console.WriteLine("Hi");
```

### Параметры функции

```C#
int Sum(int x, int y) => x + y; // Тут x и y - параметры

Sum(5, 6); // Тут 5 и 6 - аргументы
```

#### Необязательные параметры

```C#
void PrintPerson(string name, int age = 1) {
    Console.WriteLine($"{name} - {age}");
}

PrintPerson("John", 5);
PrintPerson(age: 5, name: "Bob"); // Именованные параметры
```

#### Передача по ссылке

При передаче по ссылке и  зменения внутри функции меняют оригинальное значение

```C#
void Inc(ref int a) {
    a++;
}

void BadInc(int a) {
    a++;
}

int b = 5;
Inc(ref b); // b == 6
BadInc(b); // b осталась 6

Inc(b); // Так низя
Inc(5); // И так низя
Inc(ref 5); // И так тоже низя
```

#### Выходной параметр

Функция может иметь несколько выходных параметров, а так лучше return

```C#
void Sum(int a, int b, out int result) {
    result = a + b;
}

int result;

Sum(5, 6, out result);
```

#### Входные параментры

Передача по неизменяемой ссылке. Судя по всему полезно только для массивов

```C#
int Sum(in int a, in int b) {
    return a + b;
}

int a = 5;
int b = 6;
Sum(a, b);
```

#### params

*params* позволяет передать не определённое кол-во параметров. После него не может быть больше параметров

```C#
int Sum(params int[] nums) {
    int sum = 0;

    foreach (int i in nums) {
        sum += i;
    }

    return sum;
}

int[] nums = {1, 2, 3, 4};
Sum(nums);
Sum(1, 2, 3);
Sum(20);
Sum();
```

### Возвращение значений

```C#
int Sum1(int a, int b) {
    return a + b;
}

int Sum2(int a, int b) => a + b;
```