C# OOП

Парадигмы программирования

это совокупность идей и понятий, определяющих стиль написания компьютерных программ.

Каким языком является C#?

C# является объектно-ориентированным языком.

Объект
(object)

это некоторая конкретная сущность (предмет, явление). Например: стол, кошка, гроза и т.д. Другое определение - это экземпляр класса.

Какими характеристиками обладает объект?

1. состояние;
2. поведение;
3. уникальность.

Состояние объекта

это набор характеристик объекта и их значений в данный момент времени.

Поведение объекта

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

Уникальность объекта

то, что отличает его от других объектов.

Класс
(class)

это вид объектов с одинаковой структурой и поведением.

Какие элементы языка C# могут относиться к функциям-членам класса?

1. методы;
2. конструкторы;
3. деструкторы;
4. индексаторы;
5. события;
6. операторы;
7. свойства.

Экземпляр класса

объект принадлежащий некоторому классу.

Какие принципы ООП вы знаете?

1. абстракция;
2. инкапсуляция;
3. наследование;
4. полиморфизм.

Абстракция (принцип ООП)

выделение существенных характеристик объекта и существенного поведения, и отбрасывание несущественных характеристик и поведения.

Инкапсуляция (принцип ООП)

механизм языка, позволяющий объединить данные и методы, работающие с этими данными, в единый объект, и скрыть детали реализации от пользователя кода.

Наследование (принцип ООП)

процесс создания на основе старого класса нового класса, который может переопределять
члены класса-родителя и добавлять новые члены.

Полиморфизм (принцип ООП)

свойство, при котором сущности с
одинаковым интерфейсом ведут себя по-разному.

Полиморфизмом являются: перегрузка, виртуальная функция.

Зачем нужно наследование?

1. Избавиться от дублирования;
2. Полиморфизм позволяющий создавать свои классы.

Ключевое слово
sealed

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

Зачем запрещать наследование?

1. Из соображений безопасности;
2. Это улучшает производительность.

Когда не нужно наследоваться?

Если мы просто хотим использовать некоторые методы класса-родителя, чтобы выполнить свою работу.
Общее правило такое – если вы при наследовании не переопределили ни один виртуальный метод, то наследование не нужно.

Как по другому называют класс-родитель?

называют базовым классом или суперклассом.

Как по другому называют класс-наследник?

называют подклассом или производным классом.

Если у класса при объявлении не указан родитель, то кто является неявно родителем?

класс Object

Что обязан делать конструктор дочернего класса?

он обязан вызвать какой-либо конструктор родительского класса при помощи ключевого слова base.

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

неявно пишется base(), т.е. осуществляется неявный вызов конструктора родителя без аргументов.

Сокрытие метода

это когда в классе потомке можно объявить в точности такую же функцию как в родителе.

Есть два класса А и В. В обоих классах имеется функция с одинаковой сигнатурой, получается класс B произвел сокрытие метода. Как будет работать вызов сокрытой функции?

Для не виртуальной функции вызывается та реализация, которая соответствует типу переменной (ссылки).

A a = new A();
a.F(); // вызов функции класса А

B b = new B();
b.F(); // вызов функции класса B

A c = new B();
c.F(); // вызов функции класса А

Чем полезно ключевого слова new при сокрытии методов?

при его использовании избавляемся от warning при объявлении сокрытого метода.

Переопределение метода
(overriding)

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

Виртуальная функция
(virtual functions)

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

Что нужно сделать чтобы функция стала виртуальной?

- В C# чтобы функция стала виртуальной, её нужно пометить ключевым словом virtual;
- Если мы переопределяем функцию в классе-наследнике, то мы должны указать ключевое слово override;
- Если забыть слово override, то подразумевается new.

Есть два класса А и В. В обоих классах имеется функция с одинаковой сигнатурой при этом функция помечена как виртуальная и переопределена в классе B. Как будет работать вызов переопределенной функции?

Для виртуальной функции вызывается та реализация, которая определена для фактического типа объекта, а не для типа ссылки.

A a = new A();
a.F(); // вызывается функция класса A

B b = new B();
b.F(); // вызывается функция класса B

A c = new B();
c.F(); // вызывается функция класса B

Как реализованы виртуальные функции?

Для каждого класса есть таблица виртуальных функций, она одна на весь класс. В этой таблице хранятся адреса функций (функции тоже хранятся в памяти, у них есть адрес). Внутри каждого объекта хранится ссылка на таблицу, которая соответствует типу объекта. При вызове метода f, CLR смотрит в таблицу виртуальных функций для текущего объекта, и вызывает функцию по адресу, который указан в таблице. Если объект по факту принадлежит классу A, то вызовется реализация по адресу1, если классу B – то по адресу2.

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

В C# абсолютно все типы являются классами. И все типы наследуются от класса Object.

Структура.
Общее определение
(structure)

это тип данных, который внутри себя хранит несколько переменных.

Структура в C#
(structure)

это класс, который является value-типом.

Особенности структур

- Объявляются так же, как классы, но вместо слово class используется слово struct.
- Наследуются от типа ValueType;
- Есть свой генерируемый конструктор по умолчанию;
- Могут реализовывать интерфейсы;
- Автоматически определены правильно методы: Equals и GetHashCode (но работают медленно из-за реализации через рефлексию, лучше переопределять самим).

Недостатки структур

1. Полный доступ на чтение и запись ко всем полям структуры;
2. Код функций, работающих с полями структуры, находится отдельно;
3. Небезопасная логика создания экземпляров структуры;
4. Не могут наследоваться и быть родительским типом.

Какие элементы языка программирования можно реализовывать в структуре?

1. поля (члены данных структуры);
2. методы;
3. интерфейсы;
4. индексаторы;
5. свойства;
6. операторные методы;
7. события;
8. конструкторы (кроме конструктора по умолчанию).

Свойства
(properties)

это специальное поле класса, содержащее программный код доступа к внутренним переменным (полям) класса или вычисления некоторого значения.

Нестатические члены класса

1. Относятся к конкретному экземпляру класса;
2. У каждого экземпляра свои члены;
3. Для работы с ее членами нужно создавать экземпляр класса.

Статические члены класса

1. Относятся к классу в целом;
2. Члены существуют в единственном экземпляре;
3. Чтобы работать с ее членами не нужно создавать экземпляр класса.

Классы-утилиты

это классы содержащие только статические методы и статические константы.

Например: Math

Для структурирования кода в C# есть 3 отдельные вещи:

1. Папки;
2. Пространства имен;
3. Сборки.

Папки

Отвечают за структурирование файлов на диске.

За что отвечают пространства имен?
(namespace)

отвечает за логическое структурирование типов и за разрешение конфликтов имен между типами.

Пространство имен
(namespace)

это логическая группа типов.

Каким свойством должны обладать имена пространств имен?

имена следует делать уникальными для всего мира, чтобы никогда не возникало конфликта имен с чужим кодом.

Соглашения про namespace’ы и папки

1. Если файл находится непосредственно внутри project’а, то в этом файле имя namespace’а должно совпадать с именем project’а;
2. Если файл вложен в некоторые папки внутри project’а, то эти папки нужно добавлять в namespace в этом файле. Каждая папка – отдельный уровень вложенности namespace’а.

Для чего используется директива using?

1. чтобы все время не писать полные имена типов, а использовать только имя типа;
2. дать краткий псевдоним какому-либо пространству имен для разрешения конфликта имен или сократить объявление типа;
3. закрыть ресурсы при завершении работы в блоке кода.

За что отвечают сборки?
(assemblies)

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

Сборка
(assembly)

это единица развертывания в .NET. Сборка представляет из себя файл .exe или .dll. Сборка содержит типы и ресурсы

Перечисления
(Enum)

это специальный вид класса, который позволяет задать набор допустимых значений-констант.

Польза перечислений

помогают обеспечить контроль типов по сравнению с обычными статическими константами, т.е. не позволяют передать в метод что-то ещё, кроме значений этого enum’а.

Когда следует использовать Enum

следует использовать практически всегда когда какой-то из параметров метода может принимать значения только из определенного набора.

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

Что в Enum скрывается за константными значениями?

По факту enum в C# - это числовой тип. Значения констант можно задать явно и всегда иметь константу со значением 0. По умолчанию в основе лежит int, но можно указывать и другие числовые типы, к примеру byte.

Можно ли делать приведение типов между элементом enum и числом?

Да можно

Статический конструктор

это метод, который выполняется 1 раз перед первым использованием класса, и который может работать только со статическими полями класса.

Как лучше инициализировать поля класса?

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

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

1. private;
2. file;
3. private protected;
4. protected;
5. internal;
6. protected internal;
7. public.

private
(модификатор доступа)

Видимость только внутри текущего класса.

file
(модификатор доступа)

область видимости типов, ограниченная файлом, в котором он объявлен. Обусловлено это нуждами кодогенерации, а именно – желанием избежать конфликтов имён.

private protected
(модификатор доступа)

Видимость внутри текущего класса и внутри наследников только из сборки, где объявлен класс.

protected
(модификатор доступа)

Видимость внутри текущего класса и внутри его наследников, независимо от их сборки.

internal
(модификатор доступа)

Видимость внутри всей сборки, где объявлен класс.

protected internal
(модификатор доступа)

Видимость внутри всей сборки, где объявлен класс. И видимость внутри всех классов-наследниках, независимо от сборки.

public
(модификатор доступа)

Видимость везде.

Абстрактный класс
(abstract class)

это класс, экземпляры которого нельзя создать.

Зачем объявлять класс абстрактным?

Базовый класс объявляют абстрактным, если не имеет смысл создавать его экземпляры, а имеет смысл создавать только экземпляры его наследников.

Какие элементы класса могут быть абстрактными?

- поля;
- методы;
- свойства;
- индексаторы;
- события.

Какие особенности при объявлении абстрактных классов?

1. Kласс надо пометить словом abstract;
2. Абстр. класс может иметь абстрактные методы – методы без реализации. Их надо пометить словом abstract;
3. Конструктор часто делают protected;
4. Абстрактный класс может иметь обычные поля и методы;
5. Если в классе есть хотя бы один абстрактный метод или от родителей достался нереализованный абстрактный метод, то класс обязан быть абстрактным.

Когда следует делать класс абстрактным?

1. Когда нет смысл создавать экземпляры этого класса;
2. Когда непонятно на текущем уровне абстракции как реализовывать те или иные элементы и нет какой-то разумной реализации по умолчанию.

Может ли абстрактный класс быть sealed?

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

Могут ли static и private методы быть abstract?

нет, потому что их тогда нельзя будет переопределить в потомках.

Интерфейс
(interface)

это абстрактный класс, который содержит
только абстрактные методы и статические константы.

Как объявляются интерфейсы?

- нужно объявлять при помощи ключевого слова interface.
- для интерфейсов принято соглашение именования – начинать их с буквы I.

Интерфейсы реализуют или от них наследуются?

реализуют

Какие элементы можно указывать в интерфейсах?

- методы;
- свойства;
- индексаторы;
- события.

Особенности интерфейсов

1. в интерфейсе нельзя вписывать реализацию его элементов;
2. невозможно создать экземпляр интерфейса;
3. можно создать ссылку на интерфейс;
4. в интерфейсе не может быть конструкторов;
5. интерфейс не может содержать поля;
6. в интерфейсе не может быть осуществлена перегрузка операторов;
7. все методы интерфейса по умолчанию объявлены как public.

Особенности интерфейсов при использовании в классах-наследниках

1. запрещено изменять модификатор доступа для метода при его реализации;
2. невозможно объявить методы интерфейса как virtual;
3. запрещено объявлять методы интерфейса с ключевым словом static (как статические);
4. класс может реализовать несколько интерфейсов;
5. Если класс реализует интерфейс, то он должен реализовывать все его методы, либо быть абстрактным.

Когда полезны интерфейсы?

1. Чтобы указать для класса признак, который не вписывается в иерархию классов;
2. Когда хочется выделить некоторую абстракцию, но не понятно как она будет реализована. Или реализации могут быть абсолютно несхожими между собой.

Что выбрать интерфейс или абстрактный класс?

1. Часто бывает лучше обойтись интерфейсом, чтобы не потратить свой единственный шанс отнаследоваться;
2. Если для абстракции совсем нет общей логики и реализации, то стоит использовать интерфейс. Абстрактный класс полезен если общая логика имеется.

Могут ли интерфейсы наследоваться друг от друга?

Да. При этом можно наследоваться от любого количества интерфейсов.

Явная реализация интерфейса
(Часть 1)

Есть два интерфейса которые имеют одинаковые по сигнатуре методы и есть класс реализующий эти два интерфейса. В этой ситуации класс реализует методы у обоих интерфейсов. Для реализации метода конкретного интерфейса нужно указать название интерфейса перед именем через точку.

Например: void IShape.Paint();

Но в последствии класс не сможет вызвать этот метод и его сможет вызвать только интерфейс для которого была осуществлена явная реализация.

Явная реализация интерфейса
(Часть 2)

Часто используется и такой вариант – один метод реализуют по-обычному (тогда он доступен через класс), а второй метод – через явную реализацию.

Отношения между классами

1. Наследование (обобщение);
2. Реализация;
3. Зависимость;
4. Ассоциация;
5. Композиция;
6. Агрегация.

Наследование
(обобщение)

(Отношения между классами)

Наследование является базовым принципом ООП и позволяет одному классу (наследнику) унаследовать функционал другого класса (родительского). Нередко отношения наследования еще называют генерализацией или обобщением. Наследование определяет отношение IS A, то есть "является".

Реализация

(Отношения между классами)

Реализация предполагает определение интерфейса и его реализация в классах.

Зависимость

(Отношения между классами)

это слабая форма отношения использования, при котором изменение в спецификации одного влечёт за собой изменение другого, причем обратное не обязательно.

Ассоциация

(Отношения между классами)

это отношение, при котором объекты одного типа неким образом связаны с объектами другого типа. Например, объект одного типа содержит или использует объект другого типа.

Например, игрок играет в определенной команде.

Композиция

(Отношения между классами)

вид агрегации, при котором объект-целое управляет жизненным циклом объекта-части. Композиция определяет отношение HAS A, то есть отношение "имеет".

Агрегация

(Отношения между классами)

отношение часть-целое, когда один из классов содержит в себе один или несколько экземпляров другого класса. Она также предполагает отношение HAS A, но реализуется она иначе

Какие методы имеет класс Object?

1. Equals();
2. Finalize();
3. GetHashCode();
4. GetType();
5. MemberwiseClone();
6. ReferenceEquals();
7. ToString().

ToString()
(класс Object)

Метод предназначен для преобразования объекта в строку. У некоторых стандартных классов уже переопределен, но для собственных классов требуется переопределение.

Equals()
(класс Object)

Метод предназначен для проверки на равенство содержимого объектов. По умолчанию, в классе object, метод просто проверяет равенство ссылок при помощи ==. Поэтому в своих классах, если мы хотим сравнивать их объекты, нужно переопределить.

Пример переопределения метода Equals()

public override bool Equals(object o) {
// проверили что передали сам объект
if (ReferenceEquals(o, this)) return true;
// отсеяли null и объекты других классов
if (ReferenceEquals(o, null) || o.GetType() != GetType()) return false;
// привели объект к Pair
Pair p = (Pair) o;
// проверили равенство ссылок и полей
return first == p.first && second == p.second;
}

Хэш-функция

это функция, которая принимает объект и, используя данные объекта, вычисляет целое число, и обладает некоторыми свойствами.

Хэш функция должна быть связана со сравнением объектов следующим образом:

– если объекты равны, то их хэши должны быть равны;
– если объекты не равны, то их хэши желательно должны быть разными, но это не обязательно;
– если объект не менялся, то хэш не должен меняться.

хэш-код (хэш)

это результат применения хэш-функции к объекту.

Какой метод в C# отвечает за вычисление хэш-функции?

GetHashCode();

Нужно ли переопределять вместе функции GetHashCode() и Equals()?

Так как хэш-функция связана со сравнением, то методы всегда надо переопределять вместе.

Пример переопределения метода GetHashCode()

public class A {
private int a;
private double b;
private B c;

public override int GetHashCode() {
int prime = 37;
int hash = 1;
hash = prime * hash + a;
hash = prime * hash + b.GetHashCode();
hash = prime * hash + (c != null ? c.GetHashCode() : 0);
return hash;}
}

Finalize()
(класс Object)

Позволяет объекту попытаться освободить ресурсы и выполнить другие операции очистки, перед тем как он будет уничтожен во время сборки мусора.

GetType()
(класс Object)

Возвращает объект Type для текущего экземпляра. .NET распознает следующие пять категорий типов:
- Классы, производные от System.Object;
- Типы значений, производные от System.ValueType;
- Интерфейсы, производные от System.Object;
- Перечисления, производные от System.Enum;
- Делегаты, производные от System.MulticastDelegate.

MemberwiseClone()
(класс Object)

Создает неполную копию текущего объекта Object. Метод создает неглубокую копию, создавая новый объект, а затем копируя нестатические поля текущего объекта в новый объект. Если поле является типом значения, выполняется битовая копия поля. Если поле является ссылочным типом, ссылка копируется, но указанный объект не является; таким образом, исходный объект и его клон ссылаются на тот же объект.

ReferenceEquals()
(класс Object)

Определяет, совпадают ли указанные экземпляры Object. При сравнении типов значений.
Аномальное поведение в следующих случаях:
- Если objA и objB являются типами значений, они упаковываются перед их передачей в метод. При сравнении строк.
- Если objA и objB являются строками, метод возвращается true, если строка интернирована.

Record

позволяет кратко создать тип (класс или структуру), в котором сразу будут реализованы конструктор и свойства (при необходимости), а также Equals, GetHashCode, ToString, операторы == и !=, Equals, который принимает не object, а тип этого record’а, и некоторые другие вещи. В основном records используются для передачи данных (т.е. чтобы сделать тип с полями без дополнительной логики).

Некоторые особенности при создании типа Record

- Если это record-класс, то свойства будут неизменяемые, а если record-структура, то изменяемые.
- Чтобы сделать свойства record-структур неизменяемыми, нужно указать модификатор readonly.
- Record-классы (не структуры) могут наследоваться друг от друга.

Создание record структуры

public record struct Person(string FirstName, string LastName);

Примечание: это объявление в одну строку.

Создание record класса

public record class Person(string FirstName, string LastName);

Примечание: это объявление в одну строку.

Другой способ создания типа record

public record Person
{
public string FirstName { get; init; } = default!;
public string LastName { get; init; } = default!;
}

для сеттеров используется модификатор init, чтобы свойства были неизменяемыми, но можно использовать и set и свойства станут изменяемыми.

Оператор with

Оператор позволяет создать копию record’а, но с измененными значениями нужных свойств.

Person p1 = new Person(“Ivan”, “Ivanov”);
Person p2 = p1 with { FirstName = “Petr” };

Также можно создать копию:
Person p3 = p1 with {};

Делается неглубокое копирование свойств.

Исключительные ситуации или просто исключения

это ситуации когда при исполнении кода могут возникать такие ситуации, когда исполнение нашего кода не пойдет по предполагаемому сценарию.

Конструкция для обработки исключений

try-catch-finally

Классы-исключений
(exceptions)

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

Бросить исключение
(throw exception)

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

Как бросить исключение?

можно при помощи оператора throw.

Например:
throw new IOException(“Message”);

Поймать исключение

то есть сделать так чтобы выполнялся ваш обработчик исключения.

Обработать исключение

это когда обработчик исключения успешно отработал до конца, не вызвав новое исключение.

Что происходит при бросании исключения?

1. Делается проверка, находимся ли мы внутри конструкции try-catch, при этом там есть catch, который соответствует типу нашего исключения;
2. Если да, то попадаем в catch. Распространение исключения прекращается;
3. Если нет, то метод немедленно завершается, мы вместе с брошенным исключением попадаем в то место, откуда метод был вызван;
4. В этом месте выполняются действия из п.1 и т.д.

Проверка входных данных

- Часто нужно кидать исключения при проверке входных данных – в конструкторах, сеттерах и публичных методах;
- Нужно проверять все аргументы на корректность, если они некорректные, то кидать подходящее исключение с понятным сообщением.

Оператор nameof

выдает строку-имя
переменной / класса / члена класса.

Например:
if (name == null) {
throw new ArgumentNullException(nameof(name),
“name can’t be null”);
}

Что произойдет если в блоке try-catch произошло исключение которое не обрабатывается в данном блоке?

Блок catch не поймает исключение, поэтому стек вызовов будет разматываться дальше, туда, откуда вызван метод, содержащий этот try-catch.

Может ли быть в блоке try-catch несколько блоков catch?

блоков catch может быть много.

Условия на catch
в C# 6

- В новом C# можно добавлять условия на обработчики catch.
- catch сработает только если выражение внутри when даст
true, в нём можно использовать объект исключения.

Например:
try
{}
catch (MyException e) when (e.Code == 42)
{}

Если поймали исключение блоком catch, зачем его бросать повторно используя throw?

Это полезно, если мы при помощи блока catch хотим либо частично обработать исключение, либо просто записать в лог информацию о том, что произошла ошибка.

Для чего нужен в конструкции try-catch-finally блок finally?

это блок кода, который выполняется всегда после блока try или блока catch. Обычно он используется для освобождения ресурсов.
- Блок finally исполнится даже если внутри try будет return, break или continue.
- Блок finally исполнится даже если внутри catch будет return, break или continue, или будет выброшено новое исключение. В общем, блок finally выполняется реально всегда.
- return из finally запрещен.

Как должна выглядеть конструкция try-catch, если в ней удалить блок catch?

Блока catch может не быть, но тогда должен быть finally. Этот вариант полезен, если при возникновении исключения мы хотим выполнить код, обычно очистку ресурсов, но само исключение ловить и обрабатывать не хотим.

Создание своих исключений

Лучше создавать свои исключения если:
‒ В C# нет такого стандартного исключения.
‒ Свой тип исключения поможет отличить их от других исключений.
Рекомендуется заканчивать имена своих исключений на Exception.

Пример:
public class MyException : Exception {
public MyException(string message) : base(message) {}
}

Как правильно логировать исключения?

Правильно просто вызвать метод ToString у исключения:
string text = e.ToString();
Этот метод выдаст вам тип и сообщение исключения, и эту же информацию по всем InnerException’ам.

Альтернатива исключениям

Альтернатива исключениям – возвращение специальных значений из метода. Например, в некоторых случаях, если произошла ошибка, можно возвращать из метода null. Либо, если метод должен возвращать неотрицательное целое число, можно возвращать отрицательные числа в качестве кодов ошибок, а затем сравнивать результат с этими кодами.
Достоинством данного подхода является более высокая производительность. Но читаемость кода при этом существенно страдает.

Коллекция

это объект, который содержит в себе набор других объектов.

Обобщение
(generic)

средство языка C#, позволяющее создавать программный код, содержащий единственное (типизированное) решение задачи для различных типов, с его последующим применением для любого конкретного типа (int, float, char и т.д.).

Обобщения в C#

Во время исполнения если вам первый раз понадобился конкретный generic, то среда исполнения «на лету» создает класс-реализацию, где вместо типа-параметра T будет конкретный тип например string. Во всех последующих ситуациях generic класс уже сгенерирован, и он может просто использоваться.

Преимущества применения обобщений

- Упрощение программного кода;
- Обеспечение типовой безопасности;
- Исключена необходимость явного приведения типа;
- Повышение производительности.

Упрощение программного кода

(Преимущества применения обобщений)

Использование обобщений позволяет реализовывать алгоритм для любого типа элементов. Не нужно создавать похожие варианты алгоритма для различных типов (int, float, string и т.д.).

Обеспечение типовой безопасности

(Преимущества применения обобщений)

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

Исключена необходимость явного приведения типа

(Преимущества применения обобщений)

при преобразовании объекта или иного типа обрабатываемых данных.

Повышение производительности

(Преимущества применения обобщений)

При использовании обобщений структурные типы передаются по значению. При этом не выполняется упаковка (boxing) и распаковка (unboxing), которые замедляют выполнение программы.

К каким элементам языка могут быть применены обобщения?

- классы;
- структуры;
- интерфейсы;
- методы;
- делегаты.

Где применяются обобщения?

- Чаще всего generics встречаются именно в коллекциях и других контейнерах;
- Также в лямбда-функциях;
- При написании собственных обобщенных алгоритмов и классов.

Name convention для имен типов

- T – тип
- T1, T2, T3 – если типов несколько

Особые случаи:
- TKey – ключ (в ассоциативном массиве)
- TValue – значение (в ассоциативном массиве)
- И др. осмысленные имена

Ограничения, накладываемые на обобщения

(Часть 1)

1. свойства не могут быть обобщенными но могут использоваться в обобщенном классе (структуре);
2. индексаторы не могут быть обобщенными но могут использоваться в обобщенном классе (структуре);
3. перегруженные операторы (operator) не могут быть обобщенными. Однако использование параметра типа T здесь допускается;
4. события (event) не могут быть обобщенными но могут использоваться в обобщенных классах (структурах);
к обобщенному классу нельзя применять модификатор extern;

Ограничения, накладываемые на обобщения

(Часть 2)

5. типы указателей нельзя использовать в аргументах типа;
6. если в обобщенном классе (структуре) используется статическое поле (static), то в объекте каждого конкретного типа (int, double и т.д.) создается уникальная копия этого поля. То есть, нет единого статического поля для всех объектов различных типов, которые конструируются;
7. к обобщенному типу T не могут быть применены арифметические операции (+, -, * и другие), а также операции сравнения. Это связано с тем, что при создании экземпляра с типом-заполнителем (инстанциировании) вместо параметра типа может быть использован тип данных, не поддерживающий эти операции.

Формы объявления ограничений для типа T следующие:

- where T: struct — ограничение типа-значения;
- where T: class — ограничение типа-ссылки;
- where T: new() — параметр типа должен иметь конструктор без параметров (конструктор по умолчанию);
- where T: BaseClass — параметр типа должен быть классом BaseClass или классом, производным от него;
- where T: Interface — параметр типа должен реализовывать интерфейс с именем Interface.

Инвариантность

позволяет использовать только заданный тип.

Ковариантность

позволяет использовать более конкретный тип, чем заданный изначально или по другому можно использовать тип Т или его потомков.
- Работает только для ссылочных типов.
- Тип Т можно сделать ковариантным при помощи ключевого слова out.

Ограничения ковариантности

- Если тип T используется в списке аргументов какого-либо метода интерфейса, то код не скомпилируется т.е. ковариантность предназначена для типов, которые используются в типах результата методов;
- Также ковариантный тип нельзя использовать в where в качестве ограничения.

Контравариантность

позволяет использовать более универсальный тип, чем заданный изначально или по другому можно использовать тип Т или его предков.
- Работает только для ссылочных типов.
- Тип Т можно сделать контравариантным при помощи ключевого слова in.

Ограничения контравариантности

Если тип T используется в типе результата какого-либо метода интерфейса, то код не скомпилируется т.е. контравариантность предназначена для типов, которые используются в типах аргументов методов.

Nullable-типы

Чтобы присвоения переменной или параметру value type значения null, эти переменная/параметр значимого типа должны представлять тип nullable. Для этого после названия типа указывается знак вопроса ?

Как устроены Nullable-типы

Во-первых, в самом деле тип называется Nullable<_T_>, т.е. это generic. А синтаксис вроде int? вместо Nullable<_int_> – это просто удобная фича компилятора.

int? x = 3;
По смыслу это:
Nullable<_int_> x = new Nullable<_int_>(3);

Символ _ игнорируем, его приходится использовать из-за особенностей данной программы.

Свойства Value, HasValue
(Nullable-типы)

1. T Value { get; }
- Если свойство HasValue выдает true, то выдает значение, лежащее внутри nullable типа
- Иначе – кидает исключение InvalidOperationException

2. bool HasValue { get; }
- Выдает true, если внутри nullable типа есть значение.

Т.е. за счет такого поведения свойства Value имитируется ошибка при обращении к null.

Nullable-типы являются?

они являются структурами.

SOLID

Это аббревиатура, составленная из первых букв названий принципов:
- Single Responsibility (S) – принцип единственной ответственности;
- Open Closed (O) – принцип открытости/закрытости;
- Liskov Substitution (L) – принцип подстановки Лисков;
- Interface Segregation (I) – принцип разделения интерфейса;
- Dependency Inversion (D) – принцип инверсии зависимостей.

Single Responsibility principle
формулировка

Класс должен иметь единственную причину для изменения.

Single Responsibility principle
основная идея

Разбиваем класс на отдельные классы. Чтобы у каждого из этих классов была только одна
ответственность и причина для изменения.

Open/closed principle
формулировка

Программные сущности (классы, модули, функции и т.д.) должны быть открыты для расширения, но закрыты для модификации.

Open/closed principle
основная идея

Если мы не будем менять существующий код, а только писать новый код, то мы не сломаем старый код.

Liskov Substitution principle
формулировка

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

Liskov Substitution principle
основная идея

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

Interface Segregation principle
формулировка

Клиенты не должны зависеть от интерфейсов, которые они не используют.

Interface Segregation principle
основная идея

Стремитесь к тому, чтобы интерфейсы были достаточно узкими, чтобы классам не приходилось реализовывать избыточное поведение.

Dependency inversion principle
формулировка

- Высокоуровневые модули не должны зависеть от низкоуровневых модулей. Все они должны зависеть от абстракций;
- Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

Dependency inversion principle
основная идея

Зачастую, вы сперва проектируете классы нижнего уровня, а только потом берётесь за верхний уровень. Принцип инверсии зависимостей предлагает изменить направление, в котором происходит проектирование.
1. Для начала вам нужно описать интерфейс низкоуровневых операций, которые нужны классу бизнес-логики.
2. Это позволит вам убрать зависимость класса бизнес-логики от конкретного низкоуровневого класса, заменив её «мягкой» зависимостью от интерфейса.
3. Низкоуровневый класс, в свою очередь, станет зависимый от интерфейса, определённого бизнес-логикой.

Что может являться коллекцией?

- массив;
- списки;
- стеки;
- деки;
- очереди;
- множества;
- ассоциативные массивы;
- и др.

Список
(list)

первое определение

это упорядоченная коллекция элементов одного типа.

Список
(list)

второе определение

это структура данных, представляющая
собой упорядоченный набор значений, в котором значения
могут повторяться.
Значения в списке называют элементами списка.

Виды списков

1. Список на массиве;
2. Связанный список:
2.1. Односвязный;
2.2. Двусвязный.

Чем список отличается от массива?

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

Виды списков в C#

- List<_T_>; - список на массиве;
- LinkedList<_T_> - двусвязный список.

Односвязный список

представляет собой ссылку на
первый элемент списка. Эту ссылку называют головой списка (head). Первый элемент списка хранит ссылку на второй элемент,
второй элемент – на третий элемент и т.д. У последнего элемента ссылка на следующий элемент – пустая (равна null).

Зачем нужны связанные списки?

- У массива длина ограничена, а список можно расширять сколько угодно;
- У связанного списка лучше временные оценки по вставке/удалению из середины и начала, чем у массива и списка на массиве;
- В отличие от списка на массиве не требуется сплошной кусок памяти.

Двухсвязный список

это список каждый элемент которого хранит в себе две ссылки на предыдущий и последующий элемент.

Устройство двухсвязного списка

- Связанный список состоит из элементов;
- Каждый элемент хранит в себе некоторое значение и две ссылки – на предыдущий и на следующий элемент;
- У первого элемента ссылка на предыдущий элемент равна null, у последнего – ссылка на следующий равна null;
- Список также хранит в себе ссылки на первый и последний элемент, их называют head (голова) и tail (хвост) списка.

Ассоциативный массив

коллекция, которая хранит в себе
пары ключ-значение (key-value).

Устройство ассоциативных массивов

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

Ассоциативные массивы в C#

- Dictionary<_TKey, TValue_> - основана на хэш-таблице;
- SortedDictionary<_TKey, TValue_>- основана на дереве двоичного поиска.

Польза ассоциативных массивов

Быстрый поиск, особенно при использовании Dictionary. Лучше использовать мапы, если в коллекции часто требуется искать объекты. Для списка, скорость поиска линейна O(n), а для Dictionary - O(1) в лучшем случае.

Чем отличается SortedDictionary от Dictionary?

- Важное отличие – в SortedDictionary ключи всегда отсортированы, поэтому гарантирован порядок;
- SortedDictionary основан на бинарном дереве поиска – особой структуре данных;
- Класс ключа должен реализовывать интерфейс IComparable. И использовать конструктор для передачи объекта IComparer.

Для чего могут пригодиться Dictionary?

- Реализация кэша – буфера с быстрым доступом. Например, браузер может кэшировать некоторые запросы, чтобы не выполнять одинаковые запросы заново;
- Или, например, такая задача – посчитать количество вхождений всех слов в тексте. Ключом можно сделать само слово, значением – количество.

Множество

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

Когда полезны множества?

- Мы хотим, чтобы в коллекции не было дубликатов. Например, хотим хранить перечень имен или перечень идентификаторов в базе данных;
- Нам нужен быстрый поиск. Если множество реализовано на хэш-таблице, то поиск будет выполняться за O(1), а если на дереве, то за O(log N);
- Если хотим пользоваться операциями со множествами – объединение, пересечение, разность.

Множества в C#

- HashSet - основана на хэш-таблице;
- SortedSet - основана на дереве.

Все классы множеств реализуют интерфейс ISet.

Операции над множествами

HashSet<_string_> s1, s2;

1. Объединение
s1.UnionWith(s2);
2. Пересечение
s1.IntersectWith(s2);
3. Разность
s1.ExceptWith(s2);

Чем отличается SortedSet от HashSet?

- Отличие в том, что SortedSet сортирует свои элементы, поэтому гарантирован порядок обхода элементов;
- И, за счет реализации на дереве, другие временные оценки.

Стек

структура данных, работа с которой основана на принципе LIFO (Last in, first out - последний вошел, первый вышел).

Очередь

структура данных, работа с которой основана на принципе FIFO (First in, first out – первый вошел, первый вышел).

Дек

структура данных, которая поддерживает и LIFO, и FIFO. То есть поддерживает вставку и удаление элементов в оба конца.

Стеки, очереди и деки в C#

- класс Stack для стеков;
- класс Queue для очереди;
- нет деков, используют LinkedList в качестве альтернативы.

Для работы с коллекциями есть два полезных класса

1. Array – для работы с массивами;
2. Enumerable – для работы с любыми коллекциями, в том
числе массивами. Этот класс содержит кучу extension методов.

Иерархия классов коллекций C#

иерархия имеет следующую структуру:
Родитель(наследник, наследник, ...)

1. IEnumerable( IEnumerable<_T_>, ICollection);
2. IEnumerable<_T_> (Stack<_T_>, ICollection<_T_>, Queue<_T_>);
3. ICollection<_T_> (IList<_T_>, ISet<_T_>, IDictionary<_K, V_>, LinkedList<_T_>);
4.1. IList<_T_> (List<_T_>);
4.2. ISet<_T_> (HashSet<_T_>, SortedSet<_T_>);
4.3. IDictionary<_K, V_> (Dictionary<_K, V_>, SortedDictionary<_K, V_>).

Временные оценки для массивов

- Высокая скорость доступа к элементу по индексу: О(1) – константное время;
- Поиск в среднем О(n);
- Скорость вставки в середину и начало O(n).

Временные оценки для списков на массиве

- Обращение по индексу - O(1);
- Поиск по значению - O(n);
- Вставка/удаление в конце - O(1), иногда O(n);
- Вставка/удаление в начале - O(n);
- Вставка/удаление в середине - O(n).

Временные оценки для односвязных списков

- Обращение по индексу или значению - O(n);
- Вставка/удаление в конце - O(n);
- Вставка/удаление в начале - O(1);
- Вставка/удаление в середине - O(n).

Временные оценки для двухсвязных списков

- Доступ O(n);
- Поиск O(n);
- Вставка O(1);
- Удаление O(1).

Временные оценки для хэш-таблицы

- Доступ O(1) в лучшем случае, а в худшем О(n);
- Поиск O(1) в лучшем случае, а в худшем О(n);
- Вставка O(1) в лучшем случае, а в худшем О(n);
- Удаление O(1) в лучшем случае, а в худшем О(n).

Временные оценки для Dictionary

- Вставка O(1) в лучшем случае, а в случаи коллизии O(n);
- Удаление O(1) в лучшем случае, а в случаи коллизии O(n);
- Поиск O(1) в лучшем случае, а в случаи коллизии O(n).

Вставка и удаление хоть и за константное время, но константа больше, чем для List.

Временные оценки для SortedDictionary

- Вставка O(log N);
- Удаление O(log N);
- Поиск O(Log N).

Временные оценки для HashSet

- Вставка O(1), а в случаи коллизии O(n);
- Удаление O(1), а в случаи коллизии O(n);
- Поиск O(1), а в случаи коллизии O(n).

Временные оценки для SortedSet

- Вставка O(log N);
- Удаление O(log N);
- Поиск O(Log N).

Временные оценки для стеков

- Вставка O(1);
- Удаление O(1).

Временные оценки для очереди

- Вставка O(1);
- Удаление O(1).

Временные оценки для дек

- Вставка O(1) из середины O(n);
- Удаление O(1) из середины O(n);
- Доступ по индексу O(n).

Итератор

это специальный объект, который позволяет обойти элементы коллекции в некотором порядке.
Итератор имеет ссылку на текущий элемент, знает какой элемент следующий и знает, если в текущей позиции список закончился.

Методы интерфейса
IEnumerator<_T_>

1. bool MoveNext() - перемещает итератор на следующий элемент, и выдает true, если после этого шага мы не зашли за границы коллекции, false - иначе;
2. T Current { get; } - выдает текущий элемент;
3. void Reset() - сбрасывает итератор в начальное положение. Этот метод можно не реализовывать – кинуть NotSupportedException;
4. void Dispose() – позволяет очистить ресурсы, редко нужен.

Реализация итератора

реализуется через yield (либо через вложенный класс).

yield

- Компилятор особым образом обрабатывает методы, в которых есть yield.
- Там создается новый класс-итератор, который будет выдавать элементы, для которых сделали yield return.
- Когда итератор попросят выдать первый элемент, выдастся items[0], второй раз – items[1] и т.д.
- Когда метод дойдет до конца, то итерирование заканчивается.
- Но всегда можно досрочно завершить итерирование при помощи yield break.

Если в коллекции
добавились/удалились элементы за время обхода с использованием итератора тогда нужно?

Итератор должен кидать исключение
InvalidOperationException

Как проверять что произошло какое-то добавление/удаление элемента при итерировании?

- В список надо добавить поле modCount – число изменений, и менять его во всех методах удаления и добавления.
- В начале метода GetEnumerator запоминать значение modCount из списка на тот момент, а потом сравнивать с ним текущее значение.

Класс верхнего уровня
(top level class)

это класс, который не вложен ни в один другой класс.

Вложенный класс
(nested class)

это класс, который вложен в какой-либо класс.

Доступ к членам внешних классов

- Вложенные классы могут обращаться ко всем полям и методам классов, внутрь которых они вложены, даже если эти члены объявлены как private.
- К вложенным классам могут применяться любые
модификаторы видимости.

Зачем нужны вложенные классы?

- Класс полезно сделать вложенным, если он используется только одним другим классом.
- Вложенные классы могут повысить читаемость кода.
- Часто через вложенные классы реализуют итераторы коллекций – у них должен быть доступ к внутреннему устройству коллекции.

Дерево

структура данных, состоящая из связанных между собой узлов.
Математически – связный граф без циклов.

Из чего состоит дерево?

1. Ребро;
2. Корень;
3. Лист.

Ребро
(дерево)

это связь между вершинами. В программе задается ссылкой. Вообще ребро задается парой вершин.

Корень
(дерево)

это вершина, в которую не входит ни одно ребро.

Лист
(дерево)

вершина, из которой не выходит ни одно ребро.

Деревья на практике

Деревья очень часто встречаются на практике.
Например, деревьями являются:
- Структура HTML и XML документов.
- Данные в формате JSON.
- Иерархия вложенности элементов управления в графическом приложении.

Какие обходы деревьев вы знаете?

1. Обход в глубину;
2. Обход в ширину.

Как реализовать алгоритм обхода дерева в ширину?

Реализуется с использованием очереди.

Шаги алгоритма:
1. Положить в очередь корень дерева
2. Пока очередь не пуста:
- Достать элемент из очереди.
- Выполнить для этого элемента нужную работу.
- Положить в очередь всех детей этого элемента.
- Вернуться на шаг 2.

Как реализовать алгоритм обхода дерева в глубину?

В этом алгоритме используется стек

Шаги алгоритма:
1. Положить в стек корень дерева;
2. Пока стек не пуст:
- Достать элемент из стека.
- Выполнить для этого элемента нужную работу.
- Положить в стек всех детей этого элемента в обратном порядке.
- Вернуться на шаг 2.

Бинарное дерево поиска

это дерево (т.е. у узлов не более 2 детей), для каждого узла которого выполняется:
- Все дети из левого поддерева строго меньше, чем этот узел.
- Все дети из правого поддерева больше, либо равны, чем этот узел.

Сбалансированное дерево

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

Граф

это совокупность двух множеств: множества вершин и множества ребер.

Ребро

это неупорядоченная пара вершин (которые это ребро соединяет).

Множество вершин

это просто множество чисел-номеров т. е. задали каждой вершине некое число.

Путь в графе

это последовательность вершин, таких что между соседними вершинами в этой последовательности в графе есть ребро.

Связный граф

это граф, между любыми двумя вершинами которого есть хотя бы один путь.

Несвязанный граф

это граф с несколькими несвязанными вершинами и ребрами.

Цикл в графе

это замкнутый путь, т.е. у которого есть повторения
вершин.

Лес

несвязный граф без циклов. По сути – совокупность
деревьев.

Обходы графов

1. Обход в глубину;
2. Обход в ширину.

Применение графов

Графы широко применяются в задачах построения оптимальных маршрутов, расписаний, планов.

Гамильтонов цикл

это цикл, который проходит по всем
вершинам графа ровно по 1 разу. Далеко не каждый граф содержит такой цикл. Задача поиска гамильтонова цикла в графе не имеет алгоритма, работающего за полиномиальное время т.е. нет такого k, что сложность алгоритма будет O(N^k).

Неявно типизированные переменные

это переменные, в месте создания которых вместо типа переменной пишется контекстное слово var и компилятор сам подставит необходимый тип данной переменной.

Плюсы и минусы var

Плюсы:
- Очень сильно ускоряется написание кода – нужно меньше думать и писать.

Минусы:
- По коду на взгляд не понятно какой тип у переменной – нужно наводить указатель мыши на переменную в Visual Studio, чтобы увидеть тип.

Анонимный тип

это конструкция, которая позволяет объявить класс и сразу же создать объект этого класса. Являются ссылочным типом.
var x = new { X = 3, Y = 2 };

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

Применение анонимных типов

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

Некоторые особенности анонимных типов

Компилятор генерирует анонимному типу некоторое имя, но нам оно недоступно.
Если в разных местах вы объявите полностью одинаковые анонимные типы – т.е. тот же набор и порядок свойств, то это будет считаться одним и тем же типом.
У анонимного типа автоматически правильно определены методы Equals, GetHashCode и ToString. Они используют Equals, GetHashCode и ToString свойств анонимного типа.

Массив объектов анонимных типов

Можно делать массив объектов анонимных типов:

var anonimousArray = new[]
{
new { X = 3, Y = 5 },
new { X = 1, Y = -1 }
};

Extension метод

это статический метод в статическом классе, который синтаксически можно вызывать как нестатический метод.

Применение Extension методов

Их можно писать и для классов, и для интерфейсов, и даже
для массивов или generic’ов.

Плюсы и минусы extension методов

Плюсы:
- Возможность дополнить класс или интерфейс новой функциональностью, не меняя этот класс или интерфейс.
- Удобный синтаксис для статических методов

Минусы:
- По коду сразу не видно – это extension метод или обычный нестатический метод.

Делегат

это объект, который хранит ссылку на метод.

Делегат хранит внутри себя всю нужную информацию для того, чтобы можно было вызвать метод, на который он ссылается:
- Адрес метода;
- Сигнатуру;
- Целевой объект, если метод нестатический.

Стандартные делегаты

Есть несколько стандартных делегатов, которые очень
удобно использовать:

Action<_арг-ты_>
Func<_арг-ты, результат_>
Predicate<_арг-ты_>

Анонимный делегат

синтаксис, при котором описывается функция без имени, и сразу создается один объект делагата, который ссылается на эту функцию.

Замыкание

это когда функция может обращаться к переменным из того контекста, где эта функция была создана.

Лямбда-выражение

это анонимная функция, которая может использовать захваченные в замыкание переменные.

Лямбда-выражения позволяют использовать функции в качестве аргументов и возвращаемых значений.
По сути это просто еще более краткий синтаксис для анонимных делегатов.

LINQ

это удобное средство C# для работы с коллекциями и некоторыми другими сущностями (например, XML, БД).

LINQ бывает в двух вариантах, которые можно применять вместе:
- Extension методы;
- Язык LINQ.

Группы методов LINQ с IEnumerable<_T_>

1. Терминальные;
2. Промежуточные.

Терминальные методы LINQ с IEnumerable<_T_>

заставляют вычислиться все элементы: Count(), Sum(), Average(), ToList(), ToArray(), ToDictionary(), ToLookup() и др.

Промежуточные методы LINQ с IEnumerable<_T_>

не запускают вычисление коллекции, и возвращают IEnumerable<_T_>:
Where(), OrderBy(), OrderByDescending(), Select(),
Distinct(), GroupBy() и др.

Метод Where
(LINQ)

Фильтрует коллекцию по указанной функции – вызывает функцию для каждого элемента, и добавляет элемент в результат, если функция вернула для него true.

Метод Select
(LINQ)

Преобразует каждый элемент в некоторый другой элемент, возможно даже другого типа.

Метод Distinct
(LINQ)

Оставляет в последовательности только уникальные элементы, т.е. в возвращаемой последовательности не будет дубликатов.

Метод All
(LINQ)

Выдает true, если все элементы потока удовлетворяют предикату, false – иначе.

Метод Any
(LINQ)

Выдает true, если хотя бы один элемент потока удовлетворяет предикату, false – иначе.

Метод OrderBy
(LINQ)

Для сортировки по возрастанию. Выдает IEnumerable<_T_>, который отсортирован по ключу, выданному функцией keySelector.

Метод OrderByDescending
(LINQ)

Для сортировки по убыванию. Выдает IEnumerable<_T_>, который отсортирован по ключу, выданному функцией keySelector.

Метод First
(LINQ)

Выдает первый элемент коллекции. Если коллекция пуста, то метод кидает исключение.

Метод FirstOrDefault
(LINQ)

Выдает первый элемент коллекции. Если коллекция пуста, то метод не кидает исключение, а выдает значение по умолчанию для типа Т, если коллекция пуста.

Метод Skip
(LINQ)

Возвращает IEnumerable<_T_>, в котором было пропущено n первых элементов.

Метод Take
(LINQ)

Возвращает IEnumerable<_T_>, в котором не более max элементов т.е. пытается взять первые max элементов, либо столько сколько есть.

Преобразование в коллекции

После работы с LINQ, обычно надо получить обычную коллекцию. Для этого есть методы:
ToArray()
ToList()
ToDictionary() – несколько перегрузок
ToLookup()

Метод GroupBy
(LINQ)

группирует элементы по ключу.

Метод ThenBy
(LINQ)

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

Метод ThenByDescending
(LINQ)

задает дополнительные критерии для упорядочивания элементов по убыванию.

Метод Join
(LINQ)

соединяет две коллекции по определенному признаку.

Метод ToLookup
(LINQ)

группирует элементы по ключу, при этом все элементы добавляются в словарь.

Метод Aggregate
(LINQ)

применяет к элементам последовательности агрегатную функцию, которая сводит их к одному объекту.

Метод GroupJoin
(LINQ)

выполняет одновременно соединение коллекций и группировку элементов по ключу.

Метод Reverse
(LINQ)

располагает элементы в обратном порядке.

Метод Contains
(LINQ)

определяет, содержит ли коллекция определенный элемент.

Метод Except
(LINQ)

возвращает разность двух коллекцию, то есть те элементы, которые создаются только в одной коллекции.

Метод Intersect
(LINQ)

возвращает пересечение двух коллекций, то есть те элементы, которые встречаются в обоих коллекциях.

Метод Count
(LINQ)

подсчитывает количество элементов коллекции, которые удовлетворяют определенному условию.

Метод Sum
(LINQ)

подсчитывает сумму числовых значений в коллекции.

Метод Average
(LINQ)

подсчитывает cреднее значение числовых значений в коллекции.

Метод Min
(LINQ)

находит минимальное значение.

Метод Max
(LINQ)

находит максимальное значение.

Метод TakeWhile
(LINQ)

возвращает цепочку элементов последовательности, до тех пор, пока условие истинно.

Метод SkipWhile
(LINQ)

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

Метод Concat
(LINQ)

объединяет две коллекции.

Метод Zip
(LINQ)

объединяет две коллекции в соответствии с определенным условием.

Метод ElementAt
(LINQ)

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

Метод ElementAtOrDefault
(LINQ)

выбирает элемент коллекции по определенному индексу или возвращает значение по умолчанию, если индекс вне допустимого диапазона.

Метод Last
(LINQ)

выбирает последний элемент коллекции.

Метод LastOrDefault
(LINQ)

выбирает последний элемент коллекции или возвращает значение по умолчанию.

При помощи чего осуществляется ввод и вывод в C#?

осуществляется при помощи потоков
ввода/вывода (input/output streams или io streams)

Поток

это канал, по которому передаются
данные.
Данные передаются последовательно, в порядке отправки.
Нельзя возвращаться назад по потоку – что прочитано из потока, пропадает из него.
В C# за ввод и вывод отвечает один и тот же класс Stream.

Stream

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

Иерархия классов ввода/вывода C#

иерархия имеет следующую структуру:
Родитель(наследник, наследник, ...)

1. System.Object (System.MarshalByRefObject, BinaryReader, BinaryWriter);
2. System.MarshalByRefObject (Stream, TextReader, TextWriter);
3.1. Stream (BufferedStream, MemoryStream, FileStream);
3.2. TextReader (StringReader, StreamReader);
3.3. TextWriter (StringWriter, StreamWriter).

Команда
int ReadByte()

класс Stream

Читает следующий 1 байт из потока и выдает его как значение int от 0 до 255.
Если в потоке нет данных или поток закончился (например, прочитали весь файл целиком), то выдается -1.
Метод является блокирующим, т.е. последующий код не исполняется, пока либо в потоке не появятся данные, либо поток не завершится, либо выбросится исключение.

Команды
Dispose() или Close()

класс Stream

После того, как работа с потоком завершена, его обязательно нужно закрывать, вызвав метод Dispose() или Close().
Лучше всего для потоков использовать using, который закрывает ресурсы, вызывая Dispose().

Команда
abstract int Read(byte[] buffer, int offset, int count)

класс Stream

Читает следующие не более чем count байт в переданный массив buffer, начиная с индекса offset.
За раз вполне может прочитаться количество байт, меньшее чем count.
Метод возвращает количество реально прочитанных байтов.
Если поток закончился, то выдается 0.

Команда
void WriteByte(byte b)

класс Stream

Записывает переданный байт.

Команда
abstract void Write(byte[] buffer, int offset, int count)

класс Stream

Записывает в поток count байт из массива, начиная с индекса offset.
Если offset + count >= buffer.Length, то будет
исключение.

Команда
abstract void Flush()

класс Stream

Заставляет поток передать буферизованные данные в место назначения.
Следует вызывать его после операции Write для буферизованных потоков, по крайней мере в самом конце передачи.
Если используется файловый поток, то если в конце не вызвать Flush (либо не закрыть файл), то данные могут не записаться в файл.
То же самое возможно при передаче данных по сети.

Буферизованные потоки

Очень часто при работе с потоками эффективнее передавать и получать данные буферизованно, т.е. порциями. При работе с файлами и сетью рекомендуется использовать именно буферизованные потоки.
Чтобы повысить производительность, используются буферизованные потоки – BinaryReader и BinaryWriter.

BinaryReader

(Буферизованные потоки)

имеет внутри себя массив-буфер. При чтении из потока, BinaryReader грузит сразу много данных (сколько свободно в буфере). За счёт этого уменьшается число обращений к источнику данных.

BinaryWriter

(Буферизованные потоки)

имеет внутри себя массив-буфер. BinaryWriter передает данные в место назначения только когда заполнится буфер, либо вызовут Flush. За счёт этого уменьшается число обращений к месту назначения.

Символьные потоки

Байтовые потоки удобны при работе с нетекстовыми данными, но плохо подходят для работы с текстом. Для работы с текстовыми данными есть специальные классы StreamReader и StreamWriter. Они являются обертками над Stream, но все их методы работают с символами char, а не с байтами. По умолчанию они работают с Unicode, но можно задать нужную кодировку.

Команда
int Read()

(StreamReader
Символьные потоки)

Читает следующий символ из потока, выдается int в диапазоне от 0 до 65535.
Если поток закончился, то выдается -1.

Команда
string ReadToEnd()

(StreamReader
Символьные потоки)

Читает все содержимое потока с текущей позиции до конца.

Команда
int Read(char[] b, int offset, int count)

(StreamReader
Символьные потоки)

Пытается прочитать count символов, кладет их в массив,
начиная с индекса offset.
Выдает количество прочитанных символов.
Выдает 0 если поток закончился.

Команда
string ReadLine()

(StreamReader
Символьные потоки)

Читает и выдает 1 строку. Выдает null если поток закончился.

Методы класса StreamWriter

Аналогичен Stream, только его методы Write работают с символами.
Он является буферизованным и также имеется метод Flush.

Загрузка классов

Исходный код на C# компилируется в платформенно- независимый байт-код (Intermediate Language - IL) в виде сборок (assemblies). Сборка обычно – это файл .exe или .dll. Из каждого проекта в Visual Studio после компиляции, получается отдельная сборка. Когда .NET программа начинает работать, она начинает грузить нужные ей сборки по мере необходимости. Если какая-то сборка ни разу не была востребована в ходе
исполнения программы, она не будет загружена.

Состав сборки

(Я расширил информацию из презентации для кругозора взяв ее из книги)

- заголовок файла Windows;
- заголовок файла CLR;
- код CIL;
- метаданные типов;
- манифест сборки;
- дополнительные встроенные ресурсы.

Класс Type

класс для получения информации о типе данных.
- Имя класса, его модификаторы (abstract, public, sealed);
- Получить родительские классы и реализуемые интерфейс;
- Поля, их типы и модификаторы;
- Методы, их типы и модификаторы;
- Конструкторы;
и т.д.

Reflection

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

Что позволяет делать Reflection?

- Можно загрузить некоторую неизвестную во время компиляции сборку из файла;
- Понять, какие там есть типы, какие у них есть методы и конструкторы;
- Создать и использовать экземпляры этих типов, вызывать их методы, обращаться к полям.

Примеры применения Reflection

- Возможность использовать plug-in’ы для своего приложения.
- Reflection также часто используется во фреймворках. Например, в NUnit и Entity Framework.

Как получить экземпляр класса Type?

(тема: Reflection)

Способ 1 – метод GetType: В классе Object – вершине иерархии классов C#, определен метод GetType(), который выдает Type для данного объекта.
Способ 2 – оператор typeof: Позволяет получить экземпляр Type, не используя объекты, имеющие этот тип.
Способ 3 – получение типов из сборки.

Получение родительского класса

(тема: Reflection)

Пусть класс B наследуется от класса A:

Type parent = typeof(B).BaseType; // это будет тип A

Для интерфейсов и Object выдается null:

Type parent = typeof(class).BaseType; // null

Получение имени типа

(тема: Reflection)

Для типов выдается полное имя с namespace’ом:

string name = typeof(int).FullName; // System.Int32

Проверка информации о типе

(тема: Reflection)

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

bool IsAbstract
// true для абстрактных классов
bool IsNested
// true для вложенных классов
bool IsInterface
// true для интерфейсов
и др.

Проверка информации о классе

(тема: Reflection)

bool IsEnum
bool IsInterface
bool IsPrimitive
bool IsArray
bool IsAnnotation
и др.

Есть и проверки модификаторов:
bool IsPublic

Получение интерфейсов типа

(тема: Reflection)

Type t = typeof(int);
Type[] interfaces = t.GetInterfaces();
foreach (Type interface in interfaces) {
Console.WriteLine(interface.FullName);
}
// вы удивитесь, но у int реализовано 5 интерфейсов

Получение полей типа

(тема: Reflection)

Информацию о поле хранит класс FieldInfo.
Метод GetFields() выдает только public поля класса.
Метод GetField(string name) выдает public поле по имени.

Type t = typeof(MyClass);
FieldInfo[] fields = t.GetFields();
FieldInfo f = t.GetField(“publicField”);

Чтобы получить все поля, есть перегрузка этих методов, которая принимает параметр BindingFlags.

BindingFlags

(тема: Reflection)

Методы получения членов класса по умолчанию выдают только public члены. Но у этих методов есть перегрузки, которые принимают дополнительный параметр – BindingFlags. Это енум, позволяющий управлять параметрами поиска
членов класса.

Пример получения всех полей класса (независимо от
видимости) с использованием BindingFlags

(тема: Reflection)

FieldInfo[] fields = t.GetFields(BindingFlags.Instance |
BindingFlags.Public | BindingFlags.NonPublic);

FieldInfo f = c.GetField(“privateField”, BindingFlags.Instance |
BindingFlags.NonPublic);

Работа с полями

(тема: Reflection)

Можно получить и задать значение поля у объекта, используя объект FieldInfo при помощи методов GetValue(object o) и SetValue(object o, object value).
Используя Reflection можно получать и менять значения даже private и readonly полей.

FieldInfo field = o.GetType().GetField(“publicField”);
int value = (int) field.GetValue(o);
field.SetValue(o, value + 1);

Информация о конструкторах

(тема: Reflection)

Информация о конструкторах представлена классом ConstructorInfo. Получить конструкторы можно методом класса Type GetConstructors(). У метода 2 версии – без аргументов (выдает только public конструкторы) и с BindingFlags. Можно получать информацию о видимости конструктора,
типах его аргументов. Можно использовать ConstructorInfo, чтобы создать через него экземпляр класса. Метод GetConstructor(Type[] parameterTypes) позволяет получить конструктор по типу аргументов.

Работа с методами

(тема: Reflection)

Для работы с методами в Reflection используется класс MethodInfo.
Получить методы можно при помощи метода GetMethods().
Конкретный метод можно получить по имени и типам аргументов при помощи метода:
GetMethod(string name, Type[] argumentTypes)

Вызов метода

(тема: Reflection)

Вызвать метод можно при помощи метода Invoke, которому передается объект (в качестве this) и аргументы.
Если количество или типы аргументов не совпадают, то будет выброшено исключение.
MethodInfo m = typeof(string).GetMethod(“Substring”, new
Type[] { typeof(int) });
Console.WriteLine(m.Invoke(“1234”, new object[] { 2 })); // 34

Получение возвращаемого методом типа

(тема: Reflection)

Так можно получить возвращаемый методом тип:
Type returnType = m.ReturnType; // Type для String

Недостатки Reflection

(тема: Reflection)

- Работает очень медленно из-за того, что использует нативный код.
- А также теряется проверка корректности кода компилятором. Поэтому методы Reflection бросают большое количество исключений в случае ошибок.
- Еще один минус – возможность нарушить инкапсуляцию, т.к. можно обращаться и к приватным членам классов.

Сериализация

это сохранение объекта в
последовательность байт.

Десериализация

это процесс восстановления объекта из
последовательности байт.

Зачем нужна сериализация?

Сохранение данных в файл для последующей загрузки – позволяет хранить данные между запусками приложения. Например, можно так хранить настройки приложения. Передача объектов по сети или между процессами. Отправитель сериализует объект, отправляет его байты, а получатель десериализует объект из байтов.

Как добавить поддержку сериализации для своего класса?

нужно пометить класс атрибутом Serializable.

Пример:
[Serializable]
public class Person
{
private string name;
private int age;
}

Требования для работы сериализации

- Класс должен быть помечен атрибутом Serializable.
- Все родительские классы тоже должны быть помечены атрибутом Serializable.
- Все объекты, на которые ссылается данный объект, должны тоже быть сериализуемыми.

BinaryFormatter

(тема: Сериализация)

Это класс, который позволяет
сериализовывать объекты в байтовый поток и десериализовывать их.

Этот класс имеет методы:
void Serialize(Stream stream, object o)
object Deserialize(Stream stream)

Что произойдет со ссылками на другие объекты при сериализации?

- Если сериализуемый объект содержит ссылки на другие объекты, то при сериализации эти объекты тоже будут сериализованы. При десериализации все эти объекты будут прочитаны.

Переиспользование ссылок

(тема: Сериализация)

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

Атрибут NonSerialized

(тема: Сериализация)

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

Дополнительные возможности

(тема: Сериализация)

Переопределение механизма сериализации для нужных типов.
Зачем переопределять:
- уменьшение размера сериализованного объекта.
- больше производительность.

Интерфейс ISerializable

(тема: Сериализация)

Используется для контроля над процессом сериализации. В нем есть метод:

void GetObjectData(SerializationInfo info, StreamingContext context)

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

protected MyClass(SerializationInfo info, StreamingContext context)

Вызов методов при сериализации/десериализации

В классе можно написать методы, которые будут вызваны при сериализации/десериализации. У этих методов должен быть 1 аргумент – StreamingContext. И эти методы надо пометить атрибутами OnSerializing, OnSerialized, OnDeserializing, OnDeserialized. Эти методы будут вызваны в соответствующие этапы
сериализации/десериализации. Этот способ часто проще и удобнее, чем реализация ISerializable.

Версионность при сериализации

Код редко остается неизменным, и реализация класса может меняться – в ходе разработки или поддержки программы могут добавляться/удаляться/меняться поля объектов. В большинстве случаев эти изменения приводят к тому, что ранее сериализованные объекты, которые имеют старую версию, не могут быть десериализованы, когда версия изменилась. Для решения этой проблемы, существуют средства для управления версиями классов при сериализации. Некоторые изменения, однако, не делают класс несовместимым с предыдущей версией.

Что может вызвать несовместимость при десериализации

- Удаление сериализуемых полей;
- Изменение позиции класса в иерархии классов;
- Изменение факта наличия/отсутствия у поля модификатора static или атрибута NonSerialized;
- Изменение типа поля;
И др.

Метаданные

это данные о данных.

Метаданные позволяют добавить некоторую
дополнительную информацию к основной информации.

Атрибут

это средство описания метаданных в коде.

Атрибуты позволяют, например, добавить к классу дополнительную информацию о нём.
Например, кто автор класса или что-то другое
Сами по себе атрибуты ничего не делают, а просто добавляют дополнительную информацию.

Использование атрибутов

- Компилятором при компиляции. Например, это атрибут [Obsolete] – выдает warning, если тип или член является deprecated.
- Средствами генерации кода.
- Во время исполнения – их можно получить через
Reflection.
- Широко используются фреймворками:
--- Entity Framework – ORM для работы с БД;
--- NUnit – unit-тесты.

Как выглядит атрибут

В простейшем виде аннотация выглядит так:
[Serializable]

[] указывают, что это атрибут, а внутри идет его имя – Serializable.

Можно еще писать так, но слово Attribute лучше опускать, оно подразумевается:
[SerializableAttribute].

Атрибуты с конструкторами

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

[Author(“Benjamin Franklin”, “27.03.2003”)]
class MyClass
{}

Если есть конструктор без аргументов, то круглые скобки не обязательны.

Несколько атрибутов

К одной части кода можно применять несколько атрибутов:
[Author(“Ivan”)]
[Entity]
class MyClass {}

Некоторые атрибуты можно применять несколько раз:
[Author(“Ivan”)]
[Author(“Petr”)]
class MyClass {}

К чему можно применять?

К объявлению:
- класса / интерфейса / структуры / енума / делегата;
- поля / переменной / аргумента метода / свойства / события;
- метода / конструктора;
- generic параметру;
- типу результата.

А также:
- К сборке / модулю;
Можно указать что можно применять ко всему.

Свои атрибуты

Атрибуты в C# должны наследоваться от класса Attribute.
Можно сделать конструкторы для атрибутов, чтобы заполнять поля.
Соглашение именования – имена классов атрибутов должны заканчиваться на слово Attribute.

Предопределенные атрибуты

Есть множество стандартных атрибутов. Например, атрибуты для сериализации:
- [Serializable] – добавляет типу поддержку сериализации;
- [NonSerialized] – говорит, что этот член надо игнорировать при сериализации;
и др.

Атрибут для атрибута

Есть специальный вид атрибутов, которые могут применяться к другим атрибутам. «Данные о данных о данных». Они применяются при объявлении атрибута:

[AttributeUsage(AttributeTargets.Class)]
public class ClassInfo : Attribute {реализация}

Здесь атрибут ClassInfo помечен стандартным атрибутом
AttributeUsage, который позволяет навешивать наш атрибут только на классы.

AttributeUsage

Кроме указания к чему можно применять наш атрибут, атрибут AttributeUsage позволяет задать в конструкторе еще следующие настройки:
- bool AllowMultiple – если true, то позволяет навешивать несколько атрибутов этого типа на одну цель. По умолчанию значение false.
- bool Inherited – если true, то этот атрибут также автоматически неявно получают классы наследники. По умолчанию значение true.

Атрибуты в Runtime

Атрибуты можно получить через Reflection и реализовывать свою логику в зависимости от наличия определенных атрибутов.

GUI

Расшифровывается как Graphics User Interface (графический интерфейс пользователя).

Это система средств для взаимодействия пользователя с электронными устройствами, основанная на представлении всех доступных пользователю системных объектов и функций в виде графических компонентов экрана (окон, значков, меню, кнопок, списков и т. п.).

Технологии для построения десктопных приложений на .NET от Microsoft

- Windows Forms – старая технология, простая для изучения;
- WPF – более новая технология, более сложная для изучения.

Windows Forms

предоставляет классы для элементов пользовательского интерфейса, например окна, диалоги, кнопки, текстовые поля и т.д.

Форма в Windows Forms

это окно верхнего уровня.

Partial класс (частичный класс)

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

UI поток

Вся работа с графическими компонентами должна вестись в UI потоке (UI thread). Это связано с тем, что многие методы классов UI не являются потокобезопасными. Программа скомпилируется, но при работе с классами UI не из того потока будут вылетать исключения. В Windows Forms программа изначально запускается и работает в этом потоке. Если работать с UI компонентами не из этого потока, то будут вылетать исключения.

Длительные операции в десктопных приложениях

В десктопном приложении важно не блокировать UI поток, т.е. не запускать в нем долгие операции. Их нужно обязательно запускать в отдельных потоках. Иначе весь UI зависнет, пока операция не выполнится. Чтобы потом как-то повлиять на UI элементы после завершения долгой операции, нужно использовать метод Invoke, который принимает делегат Action или Func. Этот метод выполняет переданный делегат в UI потоке. Также есть свойство InvokeRequired, которое позволяет проверить, что код уже находится в нужном потоке или нет.

Toolbox

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

Properties

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

Некоторые свойства формы

- Text – заголовок окна;
- StartPosition – стартовая позиция при открытии формы;
- Size – размер;
- MaximumSize – максимальный размер;
- MinimumSize – минимальный размер;
- Icon – иконка;
- FormBorderStyle – стиль границ окна. Например, позволяет запретить менять размеры окна.

Некоторые UI элементы

- Button – кнопка;
- Label – нередактируемая надпись;
- Checkbox – чекбокс;
- RadioButton – радио-баттон;
- TextBox – поле ввода;
- Combobox – комбобокс (выпадающий список,
позволяющий ввести свое значение);
- OpenFileDialog – диалог выбора файла;
- SaveFileDialog – диалог сохранения файла;
- MenuStrip – главное меню.

Класс MessageBox

позволяет выводить модальные диалоговые окна.
Можно выводить диалог просто с сообщением, либо диалог с набором стандартных кнопок (например, OK/Да/Нет/Отмена и т.д.).
Можно выбрать вариант иконки.

Элементы-контейнеры

элементы, которые могут содержать вложенные элементы и предназначены для группировки элементов и управления их размерами и положением внутри контейнера.
У контейнеров есть свойство Controls – список вложенных элементов. Через это свойство можно добавлять/удалять элементы в контейнер.

Обработка событий

При работе с графическим интерфейсом, возникают события. Например, клики мыши, движение мыши, нажатие клавиш и т.д.
Наши программы могут реагировать на эти события при помощи обработчиков событий.

Обработчики событий

это функции, которые выполняются когда событие произошло.

Например, мы хотим при нажатии на кнопку, показать сообщение. Для этого нам нужно зарегистрировать для кнопки обработчик события нажатия на нее.

Шаблон проектирования

проверенное архитектурное решение некоторой задачи проектирования.

Observer (наблюдатель)

шаблон проектирования который используется в С# для обработки событий.

Шаблон Observer

Виды объектов, участвующих в шаблоне:
1. Есть наблюдаемый объект, события которого мы хотим отслеживать;
2. Есть объекты-наблюдатели (observer’ы), которые хотят получать оповещения о событиях наблюдаемого объекта.
Каждый вид объектов имеет свой интерфейс, например Observable или Subject – для наблюдаемого объекта, Observer или Listener – для слушателя.
Для каждого наблюдаемого объекта может быть много подписчиков.

Суть шаблона Observer

Допустим, мы – издательство, и издаем журнал. Люди подписываются на наш журнал, и когда у нас выходит новый номер, мы сами доставляем его подписчикам.
Если подписчику расхотелось получать наш журнал, то он сообщает об этом и отписывается, и мы перестаем присылать ему новые номера.

событие (event)

это конструкция языка на которой основан шаблон проектирования Observer.
Событие представляет из себя свойство-делегат и методы add/remove, которые можно переопределить. Метод add вызывается при использовании оператора += для события. По умолчанию делегат добавляется в конец текущий цепочки делегатов. А при инициировании события (вызов метода Invoke) все эти делегаты вызываются по цепочке. Метод remove вызывается при использовании оператора -= для события, тогда делегат удаляется из цепочки.

что нужно делать при работе с event?

Изначально это свойство-делегат равно null, поэтому при
работе с ним обязательно нужна проверка на null.

Сигнатура метода для event

private void button1_Click(object sender, EventArgs e) {}

- Аргумент sender – это объект, на котором произошло событие. Он может быть полезен, если один и тот же обработчик используется для разных элементов.
- Аргумент e – это объект с информацией о событии. Например, для событий мыши и клавиатуры там содержится информация какая кнопка/клавиша нажата и т.д.

В соответствии с какими шаблонами проектирования делают приложения имеющие GUI?

‒ MVC (Model-View-Controller);
‒ MVP (Model-View-Presenter);
‒ MVVM (Model-View-ViewModel).

Шаблон MVC

В шаблоне участвует три элемента:
‒ Модель (Model);
‒ Представление (View);
‒ Контроллер (Controller).

Модель (Model)

(Шаблон MVC)

это «бизнес-логика» приложения.

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

Бизнес-логика

это реализация предметной области в программе.

Например, это логика вычисления зарплаты сотрудникам или автоматизированная отправка сообщений.

Представление (View)

(Шаблон MVC)

это то, что видит и с чем взаимодействует пользователь.

Представление не должно иметь в себе бизнес-логики, оно отвечает только за отображение данных модели.

Например, это окно приложения.

Контроллер (Controller)

(Шаблон MVC)

это связующее звено между моделью и представлением.

Он переводит действия пользователя в команды над моделью.

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

Взаимодействие в MVC

Пользователь работает с представлением View, например, вводит текст, нажимает кнопки. Когда во view возникают события, они передаются контроллеру. Контроллер, используя данные о событии, меняет модель. После изменения модель (или контроллер) оповещает view, что данные изменились, и view обновляется – берет данные из модели.

Циклические зависимости и MVC

Можно подумать, что в MVC есть циклическая зависимость – view сообщает контроллеру о событии, контроллер меняет модель, модель сообщает view об изменении, затем view берет данные из модели. То есть, есть цикл между view и моделью. Чтобы разорвать эту зависимость, создается некоторый интерфейс listener’а, и модель работает с ним.
Циклические зависимости плохи тем, что использовать этот код в другом месте можно только целиком поэтому от них нужно избавляться.

Выгода MVC

- Код приложения разбивается на 3 достаточно независимые части;
- Над каждой частью может работать отдельный человек;
- Эти три части кода логично сгруппированы;
- Каждую часть можно подменить.

Как выглядит код использующий MVC

Обычно код каждой части шаблона MVC помещают в отдельные сборки или папки.

Например:
‒ Model
‒ View
‒ Controller

Шаблон MVP

В шаблоне участвует три элемента:
‒ Модель (Model);
‒ Представление (View);
‒ Представитель (Presenter).

Модель (Model)

(Шаблон MVP)

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

Представление (View)

(Шаблон MVP)

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

Представитель (Presenter)

(Шаблон MVP)

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

Выгода MVP

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

Применение MVP

Чаще всего его используют разработчики мобильных приложений, однако он гораздо популярнее, чем может показаться. Дело в том, что этот паттерн активно применяется в вебе.

Шаблон MVVM

В шаблоне участвует три элемента:
‒ Модель (Model);
‒ Представление (View);
‒ Представитель (Presenter).

Модель (Model)

(Шаблон MVVM)

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

Представление (View)

(Шаблон MVVM)

содержит только код пользовательского интерфейса. Он отображает экран (текстовые поля, ярлыки, кнопки) и пользовательский ввод.

Модель представления (ViewModel)

(Шаблон MVVM)

используются для связи между View и Model. Они обычно не содержат много логики. Они содержат Model, который должен быть использован во View. Когда человек взаимодействует с пользовательским интерфейсом, ViewModel узнает, какое действие необходимо выполнить, и просит Model сделать это.

Выгода MVVM

- Возможность итеративного произвольного стиля программирования. Изолированные изменения менее опасны и более удобны для экспериментирования.
- Упрощение модульного тестирования.
- Поддержка совместной работы команд.
- Повышение удобства обслуживания. Устранение ошибок в несвязанном коде снижает вероятность возникновения регрессий в другом коде.

Параллелизм (concurrency)

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

Виды параллелизма

1. Уровень процессов;
2. Уровень потоков.

Процесс

- программа исполняется внутри процесса;
- процесс имеет один или более потоков;
- процесс достаточно тяжеловесен - имеет множество дополнительных данных, нужных для исполнения программы;
- для взаимодействия между процессами, например, передачи данных, используются средства IPC (Inter Process Communication).

Поток

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

Определение потока (thread)

это последовательность команд для процессора.

Многопоточная программа

это программа которая имеет несколько потоков, и ее потоки могут исполняться параллельно (одновременно).

Многозадачность

возможность выполнять другую работу, пока в отдельном потоке выполняется длительная операция.

Достоинства многопоточности

- многозадачность;
- увеличение скорости работы.

Как работает поток в C#

Когда запускается программа на C#, в ОС создается отдельный процесс. Этот процесс запускает CLR, которая уже запускает саму программу на C#. Программа начинает исполняться в одном потоке, с функции Main одного из классов. Далее уже можно создавать новые потоки, если они нужны.

Класс Thread

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

Есть две стратегии работы с потоками:
- Самому создавать экземпляры Thread и работать с ними.
- Передавать задачи в пул потоков при помощи класса Task.

Создание и запуск потока

Использовать конструктор, принимающий делегат, который нужно выполнить в этом потоке:

public static void Run() {
Console.WriteLine(“Hello”); }

В main:
Thread t = new Thread(Run);
t.Start(); // этот метод запускает исполнение потока

Второй конструктор потока

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

string text = “Hello”;
Thread t = new Thread(x => Console.WriteLine(x));
t.Start(text); // этот метод запускает исполнение потока

Завершение потока

Поток завершается, когда завершается код переданного делегата. Экземпляр потока можно запускать только один раз, второй раз будет исключение ThreadStateException.
Программа в целом продолжает исполняться, пока не завершились все её потоки.

Приостановка исполнения потока

Статический метод Thread.Sleep(long millis) позволяет приостановить исполнение потока на указанное количество миллисекунд. Метод Sleep не гарантирует, что задержка будет ровно такой, точность зависит от ОС. Кроме того, этот метод может бросить исключение ThreadInterruptedException, если поток попытаются прервать, пока он спит.

Получение текущего потока

Метод join

Thread.СurrentThread; // выдает текущий поток

Иногда текущему потоку нужно дождаться завершения некоторого потока. Например, мы хотим дождаться, пока некоторый поток не прочитает данные из файла. Для этого есть метод Join:

Thread t = new Thread(someTask);
t.Start();
// … много кода
t.Join();
Console.WriteLine(“Some task ended”);

Прерывание потока

Иногда поток хочется остановить. Например, мы начали грузить большой файл по запросу пользователя, но затем пользователь нажал кнопку «Отмена». Хотелось бы остановить процесс загрузки, остановив поток. Чтобы завершить поток досрочно, следует послать ему
прерывание (interrupt).

Пример прерывания потока

В Main:

Thread t = new Thread(task);
t.Start();
// много кода
if (needExit) { t.Interrupt(); }

Если поток спал на методах Sleep, Join или Wait, то тогда поток просыпается, и в нем вылетает ThreadInterruptedException.

Как обрабатывать ошибку ThreadInterruptedException при прерывании потока

Action task = () => {
try {
Thread t = Thread.CurrentThread;
// код со Sleep/Wait/Join
} catch (ThreadInterruptedException e) {
// обработка просьбы завершить поток
}
};

Метод Abort

завершает поток, кидая в нем ThreadAbortException. Это очень особый вид исключения. Если поток в момент Abort делал что-то важное, и ему надо выполнить какой-то дополнительный код (например, освободить ресурсы), то ThreadAbortException можно поймать обычным try-catch-finally. Но особенность в том, что после catch/finally, ThreadAbortException сам вылетает снова. Если хочется убрать это поведение (т.е. вы как бы обработали остановку потока), надо в catch вызвать метод Thread.ResetAbort().

Синхронизация потоков

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

Состоянием гонки (race condition)

ситуация, когда возможен одновременный доступ разных потоков к одним и тем же данным.

Мониторы

Каждый объект (только reference-типы) в C# имеет связанную с ним сущность – монитор. Это специальный ресурс, который может использоваться для синхронизации потоков. Потоки могут захватывать и освобождать монитор. Монитором может одновременно владеть только 1 поток. Мониторы используются для создания критических секций – блоков кода, которые должны исполняться только одним потоком одновременно.

Ключевое слово lock

Для работы с мониторами используется ключевое слово lock.
Кроме того, можно работать с мониторами напрямую через класс Monitor. По сути, конструкция lock – это всего лишь try-finally, где в finally монитор обязательно освобождается.

Блок lock

Переменная obj – это некоторый объект

lock (obj) { // код критической секции }

При входе в lock блок, поток пытается захватить монитор объекта obj. Если это удается, то поток исполняет код критической секции, а при выходе из нее – освобождает монитор. Если не удается, то поток ждет, пока монитор не освободится. При этом поток тратит много ресурсов – он постоянно опрашивает состояние монитора.

Синхронизация потоков с использованием lock

Синхронизация делается по readonly переменной, чтобы не могли поменять ссылку – это правильная практика.
Не все методы обязаны иметь lock, а лишь те, где требуется взаимное исключение.

Взаимная блокировка (deadlock)

При синхронизации потоков могут возникать ситуации, когда два или более потоков оказались заблокированными. Например поток 1 успел захватить монитор А, а поток 2 - успел захватить монитор B и тогда возникает deadlock.

Deadlock

В C# нет никаких средств для распознавания или предотвращения deadlock’ов. Для избежания deadlock’ов, нужно внимательно следить за синхронизацией. Если в разных методах могут требоваться несколько мониторов, то лучше, чтобы они захватывались в одинаковом порядке. Часто, приходится ввести дополнительный монитор, который будет захватываться, когда кому-нибудь нужен будет один из других мониторов.

Атомарные операции

Операция называется атомарной, если она выполняется за один раз целиком.
Атомарные операции безопасны в многопоточной среде – разные потоки не могут вклиниться в середину такой операции.
Многие операции, например ++ и --, не являются атомарными, потому что содержат несколько этапов.

класс Interlocked

Этот класс содержит статические методы для потокобезопасных атомарных операций:
- Decrement – уменьшение на 1;
- Increment – увеличение на 1;
- Exchange – обмен переменных местами;
- CompareExchange – проверка на равенство с заменой.

Какие операции считаются атомарными?

- Доступ к переменным ссылочных и примитивных типов, кроме long и double.
- Доступ ко всем переменным, которые помечены ключевым словом volatile при объявлении.

Тут имеется в виду только присваивание и получение значения переменной.
Например, вызов метода у переменной ссылочного типа, либо инкремент volatile переменной не является атомарной операцией.

Проблемы многопоточности

- Deadlock – блокировка намертво нескольких потоков.
- Starvation – когда несколько потоков пытаются доступиться к некоторому ресурсу, и один из потоков никак не может получить этот ресурс, он всегда достается другим.
- Livelock – блокировка потоков, но при этом они работают, а не ожидают. Можно сравнить с переходом двух людей через коридор, когда люди не могут разойтись, и каждый раз движутся в одну и ту же сторону, не давая друг другу пройти.

Методы Wait, Pulse, PulseAll

Есть проблема – когда поток хочет войти в lock секцию, а монитор уже занят, то поток тратит много ресурсов, постоянно опрашивая состояние монитора.
Чтобы не тратить ресурсы, можно «усыпить» поток при помощи метода Wait(), а потом разбудить поток при помощи одного из методов – Pulse() и PulseAll().
Эти методы находятся в классе Monitor.

Deprecated методы

У класса Thread есть похожие методы – Suspend() и Resume(), которые усыпляют и пробуждают поток.
Но они являются deprecated. Причина в том, что поток при засыпании не освобождает монитор, что является частой причиной deadlock’ов.

Immutable объекты

это объекты, которые не могут менять
свое значение.
Примером immutable объектов в C# являются строки. После создания этих объектов, их содержимое нельзя изменить.
Такие объекты очень полезны в многопоточной среде, потому что они не могут измениться, и поэтому для них можно не реализовывать синхронизацию.

Создание своего immutable класса

Все поля должны быть private readonly.
Не должно быть сеттеров и методов, которые меняют состояние объекта.
Не позволять наследникам переопределять методы. Можно сделать sealed сам класс, либо его методы.

Высокоуровневая работа с потоками

В C# есть 2 класса для задач:
- Task – некоторая задача, которая не имеет результата (т.е. void функция);
- Task<_T_> - задача, которая имеет результат типа T.

Фоновый поток

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

Пул потоков

класс, который заранее создал несколько потоков, и использует их для выполнения задач т.е. при выполнении нашей задачи task поток уже существовал, просто ему на исполнение передалась наша задача.

Создание и запуск задачи

Task task = new Task(() => Console.WriteLine(“OK”));
task.Start();

Задача будет выполнена в фоновом потоке внутри пула потоков.

Потребители

это потоки пула потоков, которые просыпаются, когда появляются новые задачи, берут эти задачи и выполняют их. Если задачи в очереди кончаются, потоки засыпают.

Производители

это те, кто кладет в очередь задач новые задачи.

Реализация собственного пула потоков

Делается это так:
- Заводится очередь задач, например, Action или Func<_T_>
- Для унификации можно всегда использовать Func<_T_>, а если передают Action, то создавать Func<_T_>, который вызывает Action и возвращает null.
- Для очереди задач делается синхронизация с Wait-PulseAll, как в задаче производитель-потребитель.

Работа с Task

Для работы с Task есть огромное число методов, позволяющих:
- Дождаться выполнения одной или набора задач;
- Отменить задачу;
- Скомпоновать задачи;
- ... и т.д.

Сетевой протокол

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

Классификация протоколов

Наиболее используемая классификация протоколов – так называемая, модель OSI (Open System Interconnection).

модель OSI
(Open System Interconnection)

- физический;
- Канальный;
- Сетевой;
- Транспортный;
- Сеансовый;
- Представления;
- Прикладной.

Физический

(модель OSI)

Функция: Кодирование и передача данных.

Пример протокола: IEEE 802.3.

Канальный

(модель OSI)

Функция: Физическая адресация.

Пример протокола: IEEE 802.3, ARP, DHCP.

Сетевой

(модель OSI)

Функция: Логическая адресация и маршрутизация пакетов.

Пример протокола: IP, ICMP.

Транспортный

(модель OSI)

Функция: Соединение конец-в-конец, контроль передачи данных.

Пример протокола: TCP, UDP.

Сеансовый

(модель OSI)

Функция: Взаимодействие хостов (на уровне ОС).

Пример протокола: NetBIOS, PAP.

Представления

(модель OSI)

Функция: Представление данных, шифрование и т.д.

Пример протокола: MIME, SSL.

Прикладной

(модель OSI)

Функция: Прикладная задача.

Пример протокола: HTTP, SMTP, DNS.

TCP
(Transmission Control Protocol)

Протокол TCP похож на телефонный разговор:
- Сначала нужно установить соединение при звонке;
- Как телефонные линии, TCP гарантирует, что отправленные данные будут доставлены, причем в том же порядке;
- Такие протоколы как HTTP, FTP требуют надежного соединения, поэтому они используют TCP.

UDP
(User Datagram Protocol)

Протокол UDP похож на отправку телеграммы почтой России:
- Факт доставки не гарантируется;
- Не гарантируется порядок доставки – старое сообщение может дойти быстрее нового;
- Все сообщения независимы друг от друга.

Порты

Компьютер обычно имеет один физический канал до сети, однако передавать или получать данные из сети могут хотеть сразу много различных приложений. Для того, чтобы понимать, какому приложению нужно передавать данные, используются порты. Данные, передаваемые по сети, содержат в себе информацию об адресате, по которой можно определить компьютер и порт. Компьютер идентифицируется 32-битным IP-адресом, а порт - 16-битным числом т.е. порт находится в диапазоне от 0 до 65 635. Порты от 0-1023 запрещены: они зарезервированы для специальных служб и приложений.

Класс Uri

Это класс который позволяет удобным образом получать части URL и работать с ними.
Он является immutable – после создания объекта URL, нельзя поменять его. Для создания Uri можно использовать класс UriBuilder. Все конструкторы класса Uri бросают исключение UriFormatException, если переданный URL некорректен.

Класс WebClient

высокоуровневый класс, который позволяет:
- Грузить данные из Uri как файл/строку/массив байт. Методы DownloadFile, DownloadString, DownloadData;
- Отправлять на Uri данные как файл/строку/массив байт. Методы UploadFile, UploadString, UploadData.

Класс HttpWebRequest

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

Сокет (socket)

это конечная точка (endpoint) двустороннего канала между компьютерами. При установке TCP соединения, каждая из сторон имеет свой сокет. Каждый сокет привязан к некоторому порту. Каждая из сторон может читать данные из сокета, и передавать данные в сокет, и они будут отправлены на другой конец.

Клиент и сервер

При взаимодействии по TCP выделяется две стороны:
- Сервер – компьютер, который имеет некоторый ресурс, либо который предоставляет некоторый сервис;
- Клиент – компьютер, который хочет получить от сервера некоторый ресурс, либо воспользоваться сервисом
сервера.

Сервер
(Часть 1)

Сервер обычно действует так – у него на некотором порту есть специальный серверный сокет, который ожидает входящие соединения от клиентов. Чтобы присоединиться к серверу, клиент должен знать адрес и порт этого серверного сокета.
Клиент пытается присоединиться к серверному сокету, при этом он открывает клиентский сокет на своей стороне, порт выбирается автоматически.
Сервер может принять или отклонить соединение со стороны клиента.

Сервер
(Часть 2)

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

Клиент-сервер и успешное соединение

Если соединение прошло успешно, то и клиент, и сервер имеют по одному клиентскому сокету для общения друг с другом. Из этих сокетов можно читать/писать данные при помощи потоков ввода/вывода.
При использовании TCP, адрес каждой стороны определяется IP адресом и номером порта. Каждое TCP соединение уникально определяется адресами своих концов.

Обслуживание многих клиентов

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

IP-адреса, DNS

Все компьютеры, чтобы общаться между собой, используют IP-адреса, а не имена компьютеров или доменные имена. Для работы с IP адресами используется класс IPAddress. Когда мы используем при соединении имя хоста (например, запрашивая страницу в браузере http://ya.ru), то сначала имя ya.ru должно быть преобразовано в IP-адрес. Преобразовать имя хоста в IP-адрес помогает DNS (Domain Name System) – это распределенная система, которая хранит в себе информацию о соответствии между именами хостов и их IP-адресами.

Класс Dns

используется для работы с DNS.
Получение информации по домену или по IP адресу:
IPHostEntry hostInfo = Dns.GetHostEntry(“www.ya.ru”);
У класса IPHostEntry есть свойства:
- HostName – имя хоста
- AddressList – список IP адресов