TeachMeSkills C# .NET

2021-01-27T18:36:27.099Z

Заметка: заметки никак не связаны с основным конспектом. Можно воспользоваться поиском по слову Заметка, чтобы найти все инсайты.

27.01
Занятие 2

Заметка: Stepik – сайт с курсами. Проходишь пару уроков, и тебе присылают лицензию на IDE от JetBrains. Она удобнее вижлы. Для C# называется Rider. В него встроен решарпер – автоматическая проверка кода на сложные ошибки.

Заметка:
Ctrl K C – закомментить код
Ctrl K U – раскомментить код
Ctrl K F – форматировать код

Самые ходовые типы:

int – целое число. Всегда 4 байта, независимо от архитектуры, в отличие от других языков.
double – дробное число, только надо в конце d ставить, например double a = 10.56d. UPD: букву d писать необязательно.
decimal – для точных вычислений, например денег. В конце ставить m.

Если хотим беззнаковый тип, добавляем u перед типом. Например, uint. Это тот же int, только он не может быть отрицательным.

Перед именем типа можно добавить слово const, тогда созданная переменная станет константной, то есть программа не даст ее изменить. То есть:

const int a = 5;
a = 7;

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

Мы можем вместо имени типа писать var, тогда компилятор сам определит тип переменной. Этакая помощь программисту.

Нельзя делать проверку на равенство, если пользовался дробными числами. Это рандом. Например тут неизвестно, true будет или false:

double a = 5.5 + 4.5;
Console.WriteLine(f == 10)

Лучше делать так:

Console.WriteLine(f > 10 - 0.001 || f < 10 + 0.001);

В языке C# переменная char занимает всегда 2 байта.

Области памяти

Две области памяти – стек и куча. Стек работает по принципу "первый вошел – последний вышел". Визуализация – стопка книг. Стек может занимать максимум 100 мегабайт.

Каждая объявленная переменная по очереди записывается в стек. Но это работает только с простейшими типами. Объекты более сложных типов (например, пользовательских классов) записываются в кучу, а в стек помещается только указатель на этот объект. Создавать объекты таких сложных типов следует вот так:

Type a = new Type();

Рассмотрим код:

MyType a1 = new MyType();
a1.Name = "Egor";
MyType a2 = a1;
a2.Name = "Alex";

Console.WriteLine(a1.Name);
Console.WriteLine(a2.Name);

Вывод:

Alex
Alex

Изменились имена и в а1, и в а2, потому что обе эти переменные – указатели на один и тот же объект, лежащий в куче. а1 и а2 это не два отдельных объекта, а условно два имени для одного и того же объекта.

Если мы хотим, чтобы созданный указатель ни на что не указывал, объявлять его нужно так:

MyType a = null;

Если мы попробуем сделать так:

a.Name = "Egor";

то вылетит ошибка, потому что указатель а ни на что не указывает. Он не привязан ни к какому объекту в куче.

Циклы

int i = 0;
while(i < 5)
{
   Console.WriteLine(i);
   i++;
}

Вывод:

0
1
2
3
4

int i = 0;
do
{
   Console.WriteLine(i);
   i++;
}
while (i < 5)

Вывод будет такой же. При использовании do while цикл гарантированно выполнится минимум один раз.

for (int i = 0; i < 5; i++)
{
   Console.WriteLine(i);
}

Вывод будет такой же. В цикле for пишется через точку запятой:

действие, которое выполнится перед первой итерацией
условие выполнения цикла
действие, которые выполняется в конце каждой итерации

Любое поле в for можно оставить пустым. То есть for( ; ; )

Заметка: если в логическом блоке (цикл или условие) только одна строка, то скобочки {} можно не ставить. Лёша рекомендует ставить их в любом случае.

Заметка: чтобы сделать цикл бесконечным, нужно вместо условия вписать true. Например while(true).

Условия

С if else всё понятно, описывать не буду.

Про switch case. Работает это так:

switch (numberOfDay)
{
   case 1:
      Console.WriteLine("понедельник");
      break;
   case 2:
      Console.WriteLine("вторник");
      break;
   case 3:
      Console.WriteLine("среда");
      break;
   default:
      Console.WriteLine("не день недели");
      break;
}

В зависимости от значения переменной numberOfDay выполнится код одного из кейсов. Если переменная будет равна 2, программа выведет "вторник". В конце каждого кейса обязательно писать break. Блок default выполняется в случае, если мы не попали ни в один из кейсов. В нашем случае например если numberOfDay равна 834, то выведется "не день недели".

Заметка: желательно изучить дома что такое enum. {DONE}

01.02
Занятие 3

Разбор вопросов по Git

Команды Git которые можно погуглить:

git checkout <хешкод коммита> – переключиться на коммит, код которого мы указали.
git cherry-pick <хешкод коммита> – скопировать указанный коммит на токующую ветку.
git reset --hard HEAD~1 – поменять HEAD (последний коммит) ветки. Цифра после тильды – на сколько коммитов сдвинуть HEAD влево. Другими словами, сколько последних коммитов удалить.

Кнопка Compare на GitHub помогает посмотреть изменения, сделанные в текущей ветке по сравнению с main. Если всё ок, то можно делать Pull Request. Главное не забыть добавить Алексея (radzevich) в Reviewers. Для того, чтобы иметь право добавлять человека в ревьюеры, нужно сначала добавить его в Collaborators. Когда человек примет приглашение и станет коллаборатором, тогда уже можно будет добавлять его в ревьюеры пул реквеста.

Ревьюеры могут комментировать код, вплоть до каждой строки. Когда ревьюер одобряет пул реквест, то напротив ревьюера в меню Reviewers появится галочка. Когда такую галочку от Алексея получаем, можем делать merge.

git branch -d – удаление ветки локально. Прежде чем удалить ветку, надо с нее слезть (пересесть на ветку main). Это делается командой git checkout main. Если при попытке удаления ветки гит ругается, а вы уверены, что всё норм, то юзаем команду git branch -D. Буква Д большая.

git pull – подтянуть на комп изменения с гитхаба. Например когда на гитхабе одобрили пул реквест и замержили (объединили) ветки. На гитхабе эти изменения есть, а локальный гит об этом еще не знает. Команда pull помогает компу узнать об изменениях, сделанных на GitHub.

Для каждой новой домашки мы будем создавать отдельную ветку, беря за основу ветку main. То есть сначала переключаемся в main, а потом создаем новую ветку.

Алексей: если копируете код из интернета, обязательно разберитесь, как он работает. Не копируйте просто так.

Заметка: Пример хорошо сделанной домашки DaysOfWeek.Master – Денис Волохович

Типы. Повторение

Иногда можно встретить стрёмные типы вроде System.UInt32. Это то же самое что uint. И соответственно. Например System.Decimal = decimal.

Операторы

Классификация по количеству операндов:

унарные – x++, ++x
бинарные – x + y, x = y, x < y, x += y

Классификация по назначению:

арифметические (+, -, ++, +=, *, %, /)
логические (!, &, |, ^)
сравнения (==, !=, <, >, <=, >=, ?)
default
nameof

Различия постфиксных и префиксных унарных операторов (x++ или ++x):

Console.WriteLine(i); //output: 3
Console.WriteLine(i++); //output: 3
Console.WriteLine(i); //output: 4

Console.WriteLine(i); //output: 3
Console.WriteLine(++i); //output: 4
Console.WriteLine(i); //output: 4

Теперь про оператор деления. Если мы делим целое число на целое число, то дробная часть отбрасывается. 13/5 = 6. Чтобы получить дробное число, надо один из операндов привести к дробному числу.
То есть double(13)/5 = 2.6 или 13/5.0 = 2.6

Приоритет выполнения операций

x++, x--
++x, --x, унарные операторы + и -
*, /, %
аддитивные операторы + и -

Алексей: лучше использовать круглые скобки, даже если приоритет операций менять не нужно. Так проще разобраться. А еще лучше разбивать сложные вычисления на отдельные строки. Код так будет читабельнее.

Важно помнить про ошибки округления.

Логические операторы

Логическое отрицание – !

!false = true = 1
!true = false = 0

Логическое и – &&
Получаем true только если оба условия true.

Логическое или – ||
Получаем true если хотя бы одно условие true. Получаем false только если оба false.

Логическое либо – ^
Получаем true если только одно true.

Логические операторы чаще всего используются в if() или в условии выполнения циклов, например while().

Можно использовать и одинарные операторы, типа &, |. Но они в любом случае вычисляют оба операнда. А двойные делают минимальное необходимое количество вычислений. То есть если в if( условие1 && условие2) первое условие будет false, то второе даже не будет вычисляться – итогом сразу будет false.

Алексей: лучше всегда использовать двойные. Одинарные могут понадобиться при более сложных задачах, например зашифровать что-то.

Тернарный оператор – ?

classify = (input >= 0) ? "nonnegative" : "negative"

Выводит первое значение (nonnegative) если условие верно. Выводит второе (negative) если неверно.

Заметка: эти два кода эквивалентны:

bool isOk = true;
if(isOk == true)

bool isOk = true;
if(isOk)

Оператор default

int a = default // a = 0
object o = default // o = null

Оператор nameof

Возвращает имя переменной, свойства объекта метода, типа и т.д.

Console.WriteLine(nameof(numbers.Count)); // output: Count

Чаще всего используется для ведения логов.

Заметка: Как переименовать переменную/функцию/метод сразу по всему коду? Нажать на нее, затем два раза нажать Ctrl + R, а затем ввести новое имя.

Заметка: использовать Culture чтобы сделать программу универсальной для разных регионов. Например, у нас принято выводить дату как ДД.ММ.ГГГГ, а в Англии ММ.ДД.ГГГГ.

03.02
Занятие 4

Массивы

Массив – коллекция переменных одного типа.

int[] a = new int[10]; – массив из десяти переменных типа int. У них нет имени, имя есть только у самого массива. Если мы хотим обратиться к конкретной переменной (например пятой в массиве), то пользуемся индексом – a[4]. Индексация ячеек начинается с нуля, поэтому у пятого по счету элемента индекс будет 4. У первого элемента индекс 0.

Многомерные массивы – массивы, в ячейках которого лежат другие массивы. Таким образом можно реализовать сетку, то есть матрицу (типа шахматное поле). Трехмерный массив задает трехмерное пространство.

int[,,] a3 = new int[10, 5, 2]; – создание трехмерного массива, то есть задание трехмерного пространства 10x5x2. Обращение к элементу массива происходит так: a3[7, 2, 1] = 4

Можно создать не многомерный массив, а реально массив массивов. В этом случае в ячейках внешнего массива могут лежать внутренние массивы разной длины.

int[][] a = new int[3][];
a[0] = new int[10];
a[1] = new int[5];
a[2] = new int[20];

В этом случае обращение к элементу массива выглядит так: a[1][3] = 4

Важно: длина многомерного массива равна произведению количества ячеек внешнего массива на количество ячеек внутреннего. То есть длина массива a[3,2] равна 6. А длина массива массива a[3][2] равна 3.

Алексей: лучше пользоваться массивами массивов, чем многомерными массивами. На продакшене почти всегда используются массивы массивов.

Строки

Строка это массив из элементов Char. То есть текст. В отличие от массива, ячейки строк являются неизменяемыми. В отличие от C++, в языке C# строка не имеет никаких нулевых символов.

Варианты инициализации строки:

string msg = System.String.Empty; //пустая строка

string msg = "Hello World!";

// два слеша читаются как один слеш, потому что слеш это служебный символ
string msg = "c:\\Program Files\\Microsoft Visual Studio";

// собачка говорит нам не считывать служебные символы,
// в этом случае можно юзать один слеш
string msg = @"c:\Program Files\Microsoft Visual Studio";

// константу можно использовать, если строка используется много раз
const string msg = "Error!";

Строки можно форматировать с помощью string.Format(). Есть множество параметров, облегчающих жизнь. Записывать не буду :)

Вместо string.Format() можно использовать интерполяцию, то есть ставить перед строкой значок $.

Заметка: чтобы изменять строку, не создавая при этом новую, нужно использовать StringBuilder. Об этом часто спрашивают на собесах.

Методы

Код выносится в отдельный метод, если используется много раз в программе. Это делается для избегания дублирования кода.

Функция это метод, который что-то возвращает. Процедура это метод, который ничего не возвращает (void). Например:

static void PrintMyName()
{
   Console.WriteLine("Egor");
}

Теперь эти две строки будут эквивалентны:

Console.WriteLine("Egor");
PrintMyName();

Чтобы выйти из метода используется return. Даже в методах void можно написать return; чтобы закончить выполнение метода.

Методу можно задать параметры. Например:

static void PrintMyName(string name)
{
   Console.WriteLine(name);
}

Тогда вызов этого метода должен выглядеть так: PrintMyName("Egor");

Можно сделать два метода с одинаковыми именами, но разными параметрами. Тогда при вызове метода компилятор посмотрит на передаваемые параметры и сам решит, какой из методов нужен.

Методы должны обязательно отличаться либо именами, либо параметрами. Методы, которые отличаются только телами, делать нельзя.

Когда мы передаем переменную в метод в качестве параметра, а затем внутри метода изменяем ее, то изменяется только копия переменной, которая была создана специально для вызванной функции. Когда функция отработает, эта копия уничтожится. И оригинальная переменная останется неизменной. Демонстрация:

static void Main(string[] args)
{
   int a = 3;
   PlusOne(a);
   Console.WriteLine(a);
}
   
static void PlusOne(int a)
{
   a++;
}

Вывод: 3

Для функции PlusOne() создается отдельная копия переменной a, которая и изменяется. Оригинальная a не меняется. Чтобы она менялась, сделать нужно было так:

static void Main(string[] args)
{
   int a = 3;
   a = PlusOne(a);
   Console.WriteLine(a);
}
   
static int PlusOne(int a)
{
   a++;
   return a;
}

Вывод: 4

Чтобы метод мог вернуть больше чем одно значение, можно использовать out.

Чтобы в методе менять саму переменную, а не ее копию, можно использовать ref. Но использовать ref считается плохим тоном.

Чтобы задать неограниченное число параметров, можно использовать params.

Заметка: нельзя инициализировать объект Random() в цикле, потому что будет выдаваться одно и то же число. Надо инициализировать его до цикла, а в цикле уже просто вызывать метод Next().

Рекурсия

Рекурсия – когда метод вызывает сам себя. Рекурсия может быть бесконечной (пока не вызовет переполнение стека за счет того, что создаст слишком много адресов возврата и копий переменных, передаваемых в качестве параметра).

То есть нужно обязательно предусмотреть условие выхода из рекурсии.

Хорошим тоном считается использовать цикл вместо рекурсий. Если это возможно, лучше делать так.

Пример бесконечной рекурсии:

static int Increase(int a) 
{
   a++;
   a = Increase(a);
   return a;
}

Пример конечной рекурсии:

static int IncreaseUntil15(int a)
{
   if (a == 15)
   {
      return a; // will be reached when a will become 15
   }
   a++;
   a = IncreaseOn15(a);
   return a; // will never be reached
}

Тот же код, но с циклом вместо рекурсии:

static int IncreaseUntil15(int a)
{
   while (a != 15)
   {
      a++;
   }
   return a;
}

08.02
Занятие 5

Разбор домашки

Неправильно используем имена. В C# есть общепринятые понятия по именованию переменных и методов. Методы, енамы, классы стоит называть с большой буквы, каждое слово тоже с большой буквы – PrintMyName(). Переменные принято называть с маленькой буквы, каждое новое слово с большой буквы – valueTwentyOne. Глобально объявленные константные переменные называют с большой буквы – GlobalValue.

Желательно использовать Double.TryParse() вместо Convert.ToDouble(), потому что он быстрее работает. Кроме того, нам не приходится ловить исключения. Ловля исключений (try, catch – позже будем проходить) это очень затратная операция, лучше обходиться без нее.

Заметка: на собеседованиях часто просят реализовать последовательность Фибоначчи. Стандартная реализация, которая самая простая, очень неэффективна. Лучше пользоваться реализацией покруче.

Объектно-ориентированное программирование

Класс – это тип объекта. Объект – это экземпляр класса. То есть мы прописываем свойства будущих объектов, создавая класс, а затем создаем объекты этого класса с помощью команды new.

class Person
{
   // поля и методы класса, то есть его свойства
}

static void Main(string[] args)
{
   StringBuilder str = new StringBuilder();
   // создали объект str типа StringBuilder
   
   Person egor = new Person();
   // создали объект egor типа Person
   
   Person alex = new Person();
   // создали объект alex типа Person
}

Три главных принципа ООП: наследование, инкапсуляция, полиморфизм.

Наследование

Возможность создавать классы на основе других классов, наследуя их свойства и поведение. Например, наследование можно использовать следующим образом: Транспорт-Машина. Класс Машина наследует свойства и поведение класса Транспорт, добавляя свои новые свойства.

Множественного наследования в C# НЕТ! То есть нельзя сделать, чтобы класс наследовал свойства двух и более классов. Но вложенное наследование разрешено. Например Транспорт-Машина-Электрокар.

Полиморфизм

Это свойство, позволяющее иметь множество реализаций одного интерфейса. Использование методов базового типа для всех дочерних типов, не создавая множество перегрузок для каждого дочернего класса отдельно.

Инкапсуляция

Скрытие данных и реализации класса. То есть вот есть метод, он работает и работает. Как именно он работает – нас не интересует. Наш объект должен быть как черный ящик: мы не знаем, что лежит внутри, но знаем, как им пользоваться.

Модификаторы доступа

public – доступно из любого места в коде.
private – доступен только из кода в том же классе.
protected – доступен из кода в том же классе или в производных классах.
internal – доступен в пределах одного файла, то есть одного проекта.
protected internal – очень редко используется, можете погуглить.
private protected – очень редко используется, можете погуглить.

Поля класса всегда должны быть private. А чтобы иметь возможность обращаться к этим полям, создаём для каждого поля геттеры и сеттеры – методы Get и Set. В C# они создаются автоматически. Синтаксис: public string Name { get; set; }

Подробнее об ООП можно почитать, погуглив что такое SOLID. Это более подробные правила ООП.

Хотя ООП и работает медленнее, чем процедурное или функциональное программирование, и занимает больше памяти, оно предоставляет возможности для безопасного расширения программы. Сейчас ООП используется почти везде.

10.02
Занятие 6

virtual, override, abstract

Не успел ничего написать. Внимательно слушал.

Конструкторы

Person kevin = new Person("Kevin", 40);
// человек с именем Kevin возрастом 40 лет

Инициализаторы

Person kevin = new Person("Kevin", 40); // человек с именем Kevin возрастом 40 лет
{
   Name = "Egor";
   Age = 25;
}
// теперь у переменной kevin имя Egor и возраст 25,
// то есть инициализатор отрабатывает после конструктора

Статические методы, поля, классы

15.02
Занятие 7

var rectangle = shape as Rectangle;
if (shape is Rectangle rectangle)
{
   Console.WriteLine($"This shape is a rectangle");
}

Ивент

Как создавать ивент:

public delegate void OnUserCreateShapeDelegate(Shape shape);
public event OnUserCreateShapeDelegate OnUserCreateShape;

На ивенты могут подписываться только методы, которые возвращают void.

Интерфейс

Интерфейс это то же самое что абстрактный класс, только у него ВСЕ методы по умолчанию абстрактные и public, то есть перед именами методов уже не нужно писать public abstract. Соответственно, ни один из методов интерфейса не может быть реализован. Только реализован в классах-наследниках интерфейса.

Наследовать можно от нескольких интерфейсов сразу.

Когда мы переопределяем метод интерфейса, слово override писать не нужно.

Интерфейсы называются с буквы I. Например public interface IShape.

Есть множество базовых стандартных интерфейсов, например ICloneable. Если мы реализовываем этот интерфейс (грубо говоря наследуемся от интерфейса ICloneable), то мы обязаны переопределить метод Clone(), создающий копию текущего объекта.

17.02
Занятие 8

Если в классе есть объект типа StreamWriter, то этот класс обязательно должен реализовать интерфейс IDisposable. Тогда надо переопределить метод Dispose(). Это позволяет использовать using – автоматическое закрытие потока при окончании работы с ним.

Коллекции

Коллекция List

Отличается от массива наличием логики. Можно пользоваться методом Add(). Этот контейнер автоматически регулирует свой размер.

Коллекция ArrayList

Одна из первых в C#. Может одновременно хранить объекты любых типов. Содержит много крутых методов.

Коллекция List<T>

Вскобках мы задаем, объекты какого типа могут храниться в этой коллекции. Методы примерно такие же.

Коллекция Queue<T>

Dequeue() – извлекает и возвращает первый элемент в очереди.

Enqueue() – добавляет элемент в конец очереди.

Peek() – возвращает первый элемент из начала очереди без удаления.

Коллекция Stack<T>

Первый вошел, последний вышел. Стопка книг.

Dictionary<Tkey, TValue>

В качестве индекса может служить не только int, но что угодно. Используется очень часто. Крутой метод TryGetValue().

Индексатор

Позволяет сделать наш класс контейнером. Чтобы можно было обращаться по индексу. Однако с foreach он работать не будет. Чтобы работал, надо реализовать интерфейсы IEnumerable (метод GetEnumerator) и IEnumerator (методы MoveNext, Current, Reset).

Egor