Программирование и тестирование

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

класс Object

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

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

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

Для не виртуальной функции вызывается та реализация, которая соответствует типу переменной (ссылки). A a = new A(); a.F(); // вызов функции класса А B b = new B(); b.F(); // вызов функции класса B A c = new B(); c.F(); // вызов функции класса А

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

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

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

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

Для виртуальной функции вызывается та реализация, которая определена для фактического типа объекта, а не для типа ссылки. 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# абсолютно все типы являются классами. И все типы наследуются от класса Object.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Да можно

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

реализуют

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public record struct Person(string FirstName, string LastName); Примечание: это объявление в одну строку.

public record class Person(string FirstName, string LastName); Примечание: это объявление в одну строку.

public record Person { public string FirstName { get; init; } = default!; public string LastName { get; init; } = default!; } для сеттеров используется модификатор init, чтобы свойства были неизменяемыми, но можно использовать и set и свойства станут изменяемыми.

Оператор позволяет создать копию record’а, но с измененными значениями нужных свойств. Person p1 = new Person(“Ivan”, “Ivanov”); Person p2 = p1 with { FirstName = “Petr” }; Также можно создать копию: Person p3 = p1 with {}; Делается неглубокое копирование свойств.

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

try-catch-finally

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

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

можно при помощи оператора throw. Например: throw new IOException(“Message”);

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

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

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

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

выдает строку-имя переменной / класса / члена класса. Например: if (name == null) { throw new ArgumentNullException(nameof(name), “name can’t be null”); }

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

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

- В новом C# можно добавлять условия на обработчики catch. - catch сработает только если выражение внутри when даст true, в нём можно использовать объект исключения. Например: try {} catch (MyException e) when (e.Code == 42) {}

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

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

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

Лучше создавать свои исключения если: ‒ В C# нет такого стандартного исключения. ‒ Свой тип исключения поможет отличить их от других исключений. Рекомендуется заканчивать имена своих исключений на Exception. Пример: public class MyException : Exception { public MyException(string message) : base(message) {} }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Во-первых, в самом деле тип называется Nullable<_T_>, т.е. это generic. А синтаксис вроде int? вместо Nullable<_int_> – это просто удобная фича компилятора. int? x = 3; По смыслу это: Nullable<_int_> x = new Nullable<_int_>(3); Символ _ игнорируем, его приходится использовать из-за особенностей данной программы.

1. T Value { get; } - Если свойство HasValue выдает true, то выдает значение, лежащее внутри nullable типа - Иначе – кидает исключение InvalidOperationException 2. bool HasValue { get; } - Выдает true, если внутри nullable типа есть значение. Т.е. за счет такого поведения свойства Value имитируется ошибка при обращении к null.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- HashSet - основана на хэш-таблице; - SortedSet - основана на дереве. Все классы множеств реализуют интерфейс ISet.

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

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

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

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

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

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

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

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).

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

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

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

- Вставка 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).

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

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

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

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

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

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

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

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

- Вложенные классы могут обращаться ко всем полям и методам классов, внутрь которых они вложены, даже если эти члены объявлены как 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 и компилятор сам подставит необходимый тип данной переменной.

Плюсы: - Очень сильно ускоряется написание кода – нужно меньше думать и писать. Минусы: - По коду на взгляд не понятно какой тип у переменной – нужно наводить указатель мыши на переменную в 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 } };

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

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

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

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

Есть несколько стандартных делегатов, которые очень удобно использовать: Action<_арг-ты_> Func<_арг-ты, результат_> Predicate<_арг-ты_>

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

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

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

это удобное средство C# для работы с коллекциями и некоторыми другими сущностями (например, XML, БД). LINQ бывает в двух вариантах, которые можно применять вместе: - Extension методы; - Язык LINQ.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пусть класс B наследуется от класса A: Type parent = typeof(B).BaseType; // это будет тип A Для интерфейсов и Object выдается null: Type parent = typeof(class).BaseType; // null

Для типов выдается полное имя с namespace’ом: string name = typeof(int).FullName; // System.Int32

Можно узнать, является ли тип интерфейсом, классом, структурой, вложенным, абстрактным и т.д.: bool IsAbstract // true для абстрактных классов bool IsNested // true для вложенных классов bool IsInterface // true для интерфейсов и др.

bool IsEnum bool IsInterface bool IsPrimitive bool IsArray bool IsAnnotation и др. Есть и проверки модификаторов: bool IsPublic

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

Информацию о поле хранит класс FieldInfo. Метод GetFields() выдает только public поля класса. Метод GetField(string name) выдает public поле по имени. Type t = typeof(MyClass); FieldInfo[] fields = t.GetFields(); FieldInfo f = t.GetField(“publicField”); Чтобы получить все поля, есть перегрузка этих методов, которая принимает параметр BindingFlags.

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

FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); FieldInfo f = c.GetField(“privateField”, BindingFlags.Instance | BindingFlags.NonPublic);

Можно получить и задать значение поля у объекта, используя объект 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);

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

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

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

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

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

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

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

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

нужно пометить класс атрибутом Serializable. Пример: [Serializable] public class Person { private string name; private int age; }

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

Это класс, который позволяет сериализовывать объекты в байтовый поток и десериализовывать их. Этот класс имеет методы: void Serialize(Stream stream, object o) object Deserialize(Stream stream)

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

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

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

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

Используется для контроля над процессом сериализации. В нем есть метод: 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 позволяет задать в конструкторе еще следующие настройки: - bool AllowMultiple – если true, то позволяет навешивать несколько атрибутов этого типа на одну цель. По умолчанию значение false. - bool Inherited – если true, то этот атрибут также автоматически неявно получают классы наследники. По умолчанию значение true.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

класс используемый для работы с потоками. Есть две стратегии работы с потоками: - Самому создавать экземпляры 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, если поток попытаются прервать, пока он спит.

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.

Action task = () => { try { Thread t = Thread.CurrentThread; // код со Sleep/Wait/Join } catch (ThreadInterruptedException e) { // обработка просьбы завершить поток } };

завершает поток, кидая в нем ThreadAbortException. Это очень особый вид исключения. Если поток в момент Abort делал что-то важное, и ему надо выполнить какой-то дополнительный код (например, освободить ресурсы), то ThreadAbortException можно поймать обычным try-catch-finally. Но особенность в том, что после catch/finally, ThreadAbortException сам вылетает снова. Если хочется убрать это поведение (т.е. вы как бы обработали остановку потока), надо в catch вызвать метод Thread.ResetAbort().

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

ситуация, когда возможен одновременный доступ разных потоков к одним и тем же данным.

Каждый объект (только reference-типы) в C# имеет связанную с ним сущность – монитор. Это специальный ресурс, который может использоваться для синхронизации потоков. Потоки могут захватывать и освобождать монитор. Монитором может одновременно владеть только 1 поток. Мониторы используются для создания критических секций – блоков кода, которые должны исполняться только одним потоком одновременно.

Для работы с мониторами используется ключевое слово lock. Кроме того, можно работать с мониторами напрямую через класс Monitor. По сути, конструкция lock – это всего лишь try-finally, где в finally монитор обязательно освобождается.

Переменная obj – это некоторый объект lock (obj) { // код критической секции } При входе в lock блок, поток пытается захватить монитор объекта obj. Если это удается, то поток исполняет код критической секции, а при выходе из нее – освобождает монитор. Если не удается, то поток ждет, пока монитор не освободится. При этом поток тратит много ресурсов – он постоянно опрашивает состояние монитора.

Синхронизация делается по readonly переменной, чтобы не могли поменять ссылку – это правильная практика. Не все методы обязаны иметь lock, а лишь те, где требуется взаимное исключение.

При синхронизации потоков могут возникать ситуации, когда два или более потоков оказались заблокированными. Например поток 1 успел захватить монитор А, а поток 2 - успел захватить монитор B и тогда возникает deadlock.

В C# нет никаких средств для распознавания или предотвращения deadlock’ов. Для избежания deadlock’ов, нужно внимательно следить за синхронизацией. Если в разных методах могут требоваться несколько мониторов, то лучше, чтобы они захватывались в одинаковом порядке. Часто, приходится ввести дополнительный монитор, который будет захватываться, когда кому-нибудь нужен будет один из других мониторов.

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

Этот класс содержит статические методы для потокобезопасных атомарных операций: - Decrement – уменьшение на 1; - Increment – увеличение на 1; - Exchange – обмен переменных местами; - CompareExchange – проверка на равенство с заменой.

- Доступ к переменным ссылочных и примитивных типов, кроме long и double. - Доступ ко всем переменным, которые помечены ключевым словом volatile при объявлении. Тут имеется в виду только присваивание и получение значения переменной. Например, вызов метода у переменной ссылочного типа, либо инкремент volatile переменной не является атомарной операцией.

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

Есть проблема – когда поток хочет войти в lock секцию, а монитор уже занят, то поток тратит много ресурсов, постоянно опрашивая состояние монитора. Чтобы не тратить ресурсы, можно «усыпить» поток при помощи метода Wait(), а потом разбудить поток при помощи одного из методов – Pulse() и PulseAll(). Эти методы находятся в классе Monitor.

У класса Thread есть похожие методы – Suspend() и Resume(), которые усыпляют и пробуждают поток. Но они являются deprecated. Причина в том, что поток при засыпании не освобождает монитор, что является частой причиной deadlock’ов.

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

Все поля должны быть 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 есть огромное число методов, позволяющих: - Дождаться выполнения одной или набора задач; - Отменить задачу; - Скомпоновать задачи; - ... и т.д.

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

Наиболее используемая классификация протоколов – так называемая, модель OSI (Open System Interconnection).

- физический; - Канальный; - Сетевой; - Транспортный; - Сеансовый; - Представления; - Прикладной.

Функция: Кодирование и передача данных. Пример протокола: IEEE 802.3.

Функция: Физическая адресация. Пример протокола: IEEE 802.3, ARP, DHCP.

Функция: Логическая адресация и маршрутизация пакетов. Пример протокола: IP, ICMP.

Функция: Соединение конец-в-конец, контроль передачи данных. Пример протокола: TCP, UDP.

Функция: Взаимодействие хостов (на уровне ОС). Пример протокола: NetBIOS, PAP.

Функция: Представление данных, шифрование и т.д. Пример протокола: MIME, SSL.

Функция: Прикладная задача. Пример протокола: HTTP, SMTP, DNS.

Протокол TCP похож на телефонный разговор: - Сначала нужно установить соединение при звонке; - Как телефонные линии, TCP гарантирует, что отправленные данные будут доставлены, причем в том же порядке; - Такие протоколы как HTTP, FTP требуют надежного соединения, поэтому они используют TCP.

Протокол UDP похож на отправку телеграммы почтой России: - Факт доставки не гарантируется; - Не гарантируется порядок доставки – старое сообщение может дойти быстрее нового; - Все сообщения независимы друг от друга.

Компьютер обычно имеет один физический канал до сети, однако передавать или получать данные из сети могут хотеть сразу много различных приложений. Для того, чтобы понимать, какому приложению нужно передавать данные, используются порты. Данные, передаваемые по сети, содержат в себе информацию об адресате, по которой можно определить компьютер и порт. Компьютер идентифицируется 32-битным IP-адресом, а порт - 16-битным числом т.е. порт находится в диапазоне от 0 до 65 635. Порты от 0-1023 запрещены: они зарезервированы для специальных служб и приложений.

Это класс который позволяет удобным образом получать части URL и работать с ними. Он является immutable – после создания объекта URL, нельзя поменять его. Для создания Uri можно использовать класс UriBuilder. Все конструкторы класса Uri бросают исключение UriFormatException, если переданный URL некорректен.

высокоуровневый класс, который позволяет: - Грузить данные из Uri как файл/строку/массив байт. Методы DownloadFile, DownloadString, DownloadData; - Отправлять на Uri данные как файл/строку/массив байт. Методы UploadFile, UploadString, UploadData.

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

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

При взаимодействии по TCP выделяется две стороны: - Сервер – компьютер, который имеет некоторый ресурс, либо который предоставляет некоторый сервис; - Клиент – компьютер, который хочет получить от сервера некоторый ресурс, либо воспользоваться сервисом сервера.

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

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

Если соединение прошло успешно, то и клиент, и сервер имеют по одному клиентскому сокету для общения друг с другом. Из этих сокетов можно читать/писать данные при помощи потоков ввода/вывода. При использовании TCP, адрес каждой стороны определяется IP адресом и номером порта. Каждое TCP соединение уникально определяется адресами своих концов.

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

Все компьютеры, чтобы общаться между собой, используют IP-адреса, а не имена компьютеров или доменные имена. Для работы с IP адресами используется класс IPAddress. Когда мы используем при соединении имя хоста (например, запрашивая страницу в браузере http://ya.ru), то сначала имя ya.ru должно быть преобразовано в IP-адрес. Преобразовать имя хоста в IP-адрес помогает DNS (Domain Name System) – это распределенная система, которая хранит в себе информацию о соответствии между именами хостов и их IP-адресами.

используется для работы с DNS. Получение информации по домену или по IP адресу: IPHostEntry hostInfo = Dns.GetHostEntry(“www.ya.ru”); У класса IPHostEntry есть свойства: - HostName – имя хоста - AddressList – список IP адресов