День сто тридцать пятый. #ВопросыНаСобеседовании
Самые часто задаваемые вопросы на собеседовании по C#
18. В чём разница между Array и ArrayList в C#?
ArrayList - это динамический массив. Он хранит значения как объекты и изменяет размер места хранения по мере необходимости.

Ключевые методы
1. BinarySearch - возвращает позицию объекта поиска в виде целочисленного значения.
2. Insert - вставляет элемент в указанное место по индексу.
3. InsertRange - вставляет элементы как отдельные объекты в указанное место.
4. Remove - удаляет первое появление данного объекта.
5. RemoveAt - удаляет элемент по индексу.
6. RemoveRange - удаляет набор элементов из указанного диапазона.
7. Sort - выполняет сортировку элементов в порядке возрастания.
8. Reverse – упорядочивает элементы в обратном порядке.

Преимущества
1. Не хранит определённые типы данных, хранит все как объекты.
2. Нет необходимости явно выделять и освобождать место для хранения данных.
3. Имеет явные методы сортировки.
4. Может вставлять и удалять элементы между позициями.
5. Может хранить объекты.

Недостатки
1. Не является строго типизированным. Нужно выполнять приведение типов при извлечении контента. Это сказывается на производительности.
2. Использует для хранения LinkedList, поэтому для вставки или удаления по определенной позиции выполняется обход всех адресов хранения.
3. Может приводить к ошибке времени выполнения, если реальный тип элемента не будет совпадать с желаемым.

Разница между Array и ArrayList
Array
- Использует векторный массив для хранения элементов
- Размер массива должен быть определен до использования.
- Хранит данные определенного типа.
- Нет необходимости выполнять приведение типов.
- Нет методов для сортировки и вставки/удаления элементов.

ArrayList
- Использует связанный список для хранения элементов.
- Нет необходимости указывать размер хранилища.
- Хранить все элементы как объекты.
- Необходимо выполнять приведение типов.
- Имеет методы для вставки, удаления, сортировки и поиска элементов.

Источник: https://www.c-sharpcorner.com

День сто тридцать шестой. #ЗаметкиНаПолях
Лямбда-выражения. Начало
Лямбда-выражение - это блок кода (выражение или блок операторов), который обрабатывается как объект. Он может быть передан в качестве аргумента методам, а также может быть возвращен методом.
Варианты использования:
- Код для исполнения асинхронным методом, таким как Task.Run(Action).
- Выражения для запросов LINQ.
- Создание деревьев выражений.

Лямбда-выражения - это код, который может быть представлен как делегат или как дерево выражений, которое компилируется в делегат. Конкретный тип делегата лямбда-выражения зависит от его параметров и возвращаемого значения. Лямбда-выражения, которые не возвращают значение, соответствуют конкретному делегату Action с соответствующим количеством параметров. Лямбда-выражения, которые возвращают значение, соответствуют конкретному делегату Func с соответствующим количеством параметров. Например, лямбда-выражение, которое имеет два параметра, но не возвращает значения, соответствует делегату Action<T1, T2>. Лямбда-выражение с одним параметром, возвращающее значение, соответствует делегату Func<T, TResult>.
Лямбда-выражение использует =>, оператор лямбда-объявления, чтобы отделить список параметров лямбды от его исполняемого кода. Чтобы создать лямбда-выражение, указываются входные параметры (если они есть) слева от оператора лямбда-выражения, и само выражение с другой стороны. Например, однострочное лямбда-выражение x => x * x указывает параметр с именем x и возвращает значение x в квадрате.
Это выражение можно назначить:
- типу делегата:

Func<int, int> square = x => x * x;
Console.WriteLine(square(5));
// вывод: 25

- дереву выражений:

using System.Linq.Expressions;
Expression<Func<int, int>> exp = x => x * x;
Console.WriteLine(exp);
// вывод: x => (x * x)

- аргументу метода:

int[] numbers = { 2, 3, 4, 5 };
var squaredNumbers = numbers.Select(x => x * x);
Console.WriteLine(string.Join(" ", squaredNumbers));
// вывод: 4 9 16 25

При использовании синтаксиса методов для вызова Enumerable.Select в классе System.Linq.Enumerable (как в LINQ to Objects и LINQ to XML) его параметр является делегатом типа Func<T, TResult>. Лямбда-выражение является наиболее удобным способом создания этого делегата. При вызове метода Queryable.Select в классе System.Linq.Queryable (как в LINQ to SQL) тип параметра представляет собой дерево выражений Expression<Func <TSource, TResult>>. Опять же, лямбда-выражение - это краткий способ построения этого дерева выражений. Лямбда-выражения позволяют вызовам Select выглядеть одинаково, хотя на самом деле тип объекта, созданного из них, отличается.

Все ограничения, которые применяются к анонимным методам (см. https://t.me/NetDeveloperDiary/163), также применяются к лямбда-выражениям.

Продолжение следует…

Источник: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions

День сто тридцать седьмой. #ЗаметкиНаПолях
Лямбда-выражения. Продолжение
Выражения лямбды
Лямбда-выражение с выражением справа от оператора => называется выражением лямбда. Выражения лямбда широко используются при построении деревьев выражений. Выражение лямбда возвращает результат выражения и имеет следующую базовую форму:

(входные параметры) => выражение

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

Action line = () => Console.WriteLine();

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

Func<int, int, bool> testForEquality = (x, y) => x == y;

Иногда компилятор не может определить типы входных параметров. Вы можете указать типы явно:

Func<int, string, bool> isTooLong = (int x, string s) => s.Length > x;

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

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

Источник: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions

День сто тридцать восьмой. #ЗаметкиНаПолях
Лямбда-выражения. Продолжение
Лямбды операторов
Лямбда операторов напоминает лямбда-выражение, за исключением того, что оператор(ы) заключен(ы) в фигурные скобки:

(входные параметры) => {оператор;}

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

Action<string> greet = name => 
{ 
  string greeting = $"Hello {name}!";
  Console.WriteLine(greeting);
};
greet("World");
// Вывод:
// Hello World!

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

Асинхронные лямбды
Вы можете легко создавать лямбда-выражения и операторы, которые включают асинхронную обработку, используя ключевые слова async и await. В следующем примере Windows Forms содержится обработчик событий, который вызывает и ожидает асинхронный метод SomeAsyncMethod:

public Form1()
{
  InitializeComponent();
  button1.Click += button1_Click;
}
private async void button1_Click(object sender, EventArgs e)
{
  await SomeAsyncMethod();
}
private async Task SomeAsyncMethod(){…}

Обработчик нажатия на кнопку можно добавить с помощью асинхронной лямбды:

public Form1()
{
  InitializeComponent();
  button1.Click += async (sender, e) =>
  {
    await SomeAsyncMethod();
  };
}

Лямбда-выражения и кортежи
Начиная с C# 7.0, язык поддерживает кортежи как аргументы или возвращаемые значения лямбда-выражений. В некоторых случаях компилятор C# использует определение типа для определения типов компонентов кортежа.
Вы определяете кортеж, заключая в скобки список его компонентов, разделенных запятыми. В следующем примере используется кортеж с тремя компонентами для передачи последовательности чисел в лямбда-выражение, которое удваивает каждое значение и возвращает кортеж с тремя компонентами, который содержит результат умножения.

Func<(int, int, int), (int, int, int)> doubleThem = ns => (2 * ns.Item1, 2 * ns.Item2, 2 * ns.Item3);
var numbers = (2, 3, 4);
var doubles = doubleThem(numbers);
Console.WriteLine($"Кортеж чисел {numbers} удвоен: {doubles}");
// Вывод:
// Кортеж чисел (2, 3, 4) удвоен: (4, 6, 8)

Обычно поля кортежа называются Item1, Item2, и т.п. Но можно задать им имена:

Func<(int n1, int n2, int n3), (int, int, int)> doubleThem = ns => (2 * ns.n1, 2 * ns.n2, 2 * ns.n3);

Продолжение следует…

Источник: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions

День сто тридцать девятый. #ЗаметкиНаПолях
Лямбда-выражения. Окончание
Вывод типа в лямбда-выражениях
При написании лямбда-выражений часто нет необходимости указывать тип для входных параметров, поскольку компилятор может вывести тип на основе тела лямбда выражения, типов параметров и других факторов, описанных в спецификации языка C#. Для большинства стандартных операторов запросов первым вводом является тип элементов в исходной последовательности. Если вы запрашиваете IEnumerable<Customer>, то входная переменная приводится к объекту Customer, что означает, что у вас есть доступ к её методам и свойствам:

customers.Where(c => c.City == "London");

Общие правила для вывода типа:
- Лямбда должна содержать то же количество параметров, что и тип делегата.
- Каждый входной параметр в лямбда-выражении должен быть неявно преобразован в соответствующий ему параметр делегата.
- Возвращаемое значение лямбды (если оно есть) должно быть неявно конвертируемым в возвращаемый тип делегата.
Замечание: лямбда-выражения сами по себе не имеют типа, потому что общая система типов не имеет внутреннего понятия «лямбда-выражение». Однако иногда удобно неформально говорить о «типе» лямбда-выражения. В этих случаях тип относится к типу делегата или типу выражения, в которые преобразуется лямбда-выражение.

Область видимости переменных в лямбда-выражениях
Лямбда-выражение может ссылаться на внешние переменные (см. пост про анонимные методы https://t.me/NetDeveloperDiary/163), которые находятся внутри метода, определяющего лямбда-выражение, или в типе, содержащем лямбда-выражение. Переменные, захваченные таким образом, сохраняются для использования в лямбда-выражении, даже они иначе вышли бы из области видимости и подлежали бы сборке мусора.
Правила области видимости в лямбда-выражениях:
- Внешняя переменная должна быть явно определена, прежде чем она сможет быть использована в лямбда-выражении.
- Перехваченная переменная не будет собираться мусором до тех пор, пока делегат, ссылающийся на нее, не станет пригодным для сборки мусора.
- Переменные, введенные в лямбда-выражении, не видны во включающем выражение методе.
- Лямбда-выражение не может напрямую захватить параметр in, ref или out из включающего его метода.
- Оператор return в лямбда-выражении не приводит к возврату включающего его метода.
- Лямбда-выражение не может содержать оператор goto, break или continue, если цель этого оператора находится вне блока лямбда-выражения, и наоборот.

Источник: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/lambda-expressions

День сто сороковой. #ЗаметкиНаПолях
Коллекции в C#
1. Словарь Dictionary<TKey, TValue>
Словарь - это тип коллекции, который полезен, когда вам нужен быстрый поиск по ключам. Например, у вас есть список клиентов, и в рамках задачи вам нужно быстро найти клиента по его ID (или другому уникальному ключу). В списке поиск элемента линейный, и стоимость этой операции составляет O(n). Однако при использовании словаря поиск выполняется стоимостью O(1), т.е. независимо от того, насколько велик словарь, время поиска остается относительно постоянным.
При хранении или извлечении объекта в словаре необходимо указать ключ. Ключ - это значение, которое однозначно идентифицирует объект и не может быть null. Например, чтобы сохранить объект Customer в словаре, вы можете использовать CustomerID в качестве ключа.
Для создания словаря нужно указать тип ключей и значений. Например, для словаря клиентов:

var dictionary = new Dictionary<int, Customer>();
dictionary.Add(customer.Id, customer);
…
// Получаем клиента с ID 1234
var customer = dictionary[1234];

Наиболее полезные методы и свойства:

// Удаление элемента по ключу 
dictionary.Remove(1);
// Очистка словаря 
dictionary.Clear();
// Количество элементов
var count = dictionary.Count; 
// Проверка на вхождение ключа
var containsKey = dictionary.ContainsKey(1);
// Проверка на вхождение значения
var containsValue = dictionary.ContainsValue(customer1);
// Итерация по ключам
foreach (var key in dictionary.Keys)
  Console.WriteLine(dictionary[key]);
// Итерация по значениям
foreach (var value in dictionary.Values)
  Console.WriteLine(value);
// Итерация по парам ключ-значение
foreach (var keyValuePair in dictionary)
{
  Console.WriteLine(keyValuePair.Key);
  Console.WriteLine(keyValuePair.Value);
}

Почему поиск в словаре так быстр? Словарь хранит объекты в массиве, но в отличие от списка, в котором объекты добавляются в конец массива (или по указанному индексу), индекс в словаре вычисляется с использованием хеш-функции. При сохранении объекта в словаре, вычисляется хеш ключа с помощью функции GetHashCode. Затем хэш корректируется под размер массива, чтобы вычислить индекс. При поиске объекта по ключу, метод GetHashCode снова используется для вычисления хеша и индекса. Поэтому, в отличие от списков, поиск объекта в словаре не требует сканирования каждого объекта и независимо от того, насколько велик словарь, он останется чрезвычайно быстрым.

Источник: https://programmingwithmosh.com/net/csharp-collections/

День сто сорок первый. #ЗаметкиНаПолях
Коллекции в C#
2. HashSet<T>
HashSet представляет набор уникальных элементов, как математическое множество (например, {1, 2, 3}). Набор не может содержать дубликаты, а порядок элементов не имеет значения, т.е. {1, 2, 3} и {3, 2, 1} равны.
HashSet используется, когда вам нужен быстрый поиск в наборе уникальных элементов. Например, при обработке списка заказов для каждого заказа вам нужно быстро проверить, входит ли код поставщика в список корректных кодов.
HashSet, похож на Dictionary, представляет собой коллекцию на основе хеша, поэтому поиск выполняется очень быстро за время O(1). Но, в отличие от словаря, он хранит только значения без ключей. Таким образом, каждый объект должен быть уникальным, и это определяется по GetHashCode. Т.е., если вы собираетесь хранить пользовательские типы в наборе, вам необходимо переопределить методы GetHashCode и Equals в вашем типе.

Создание и использование:
- Инициализация:

var hashSet = new HashSet<int>() { 1, 2, 3 };

- Добавление:

hashSet.Add(4);

- Удаление:

hashSet.Remove(3);

- Очистка:

hashSet.Clear();

- Проверка наличия элемента:

var contains = hashSet.Contains(1);

- Количество элементов:

var count = hashSet.Count;

HashSet предоставляет набор математических операций для работы с множествами. Следующие методы имеют аналоги в LINQ для любых коллекций IEnumerable<T>:
- Пересечение множеств (изменяет hashSet):

hashSet.IntersectWith(another);

- Объединение множеств (изменяет hashSet):

hashSet.UnionWith(another);

- Удаляет все элементы another из hashSet:

hashSet.ExceptWith(another);

Следующие методы НЕ имеют аналогов в LINQ для обычных коллекций:
- Симметричная разница (изменяет hashSet), элементы из hashSet или из another, но не из обоих:

hashSet.SymmetricExceptWith(another);

- Является ли hashSet надмножеством another:

var isSupersetOf = hashSet.IsSupersetOf(another);

- Является ли hashSet строгим надмножеством another:

var isSupersetOf = hashSet.IsProperSupersetOf(another);

- Является ли hashSet подмножеством another:

var isSubsetOf = hashSet.IsSubsetOf(another);

- Является ли hashSet строгим подмножеством another:

var isSubsetOf = hashSet.IsProperSubsetOf(another);

- Содержит ли hashSet те же элементы, что и another:

var equals = hashSet.SetEquals(another);

- Есть ли у hashSet и another одинаковые элементы:

var overlaps = hashSet.Overlaps(another); 

Источник: https://programmingwithmosh.com/net/csharp-collections/

День сто сорок второй. #ЧтоНовенького
Visual Studio 2019 версии 16.2
Вышло превью Visual Studio 2019 версии 16.2. Версия доступна для загрузки с VisualStudio.com, или, если у вас отмечена установка превью версий, просто щелкните значок уведомления в Visual Studio для обновления.

Поддержка Microsoft Edge Insider
Теперь Visual Studio позволяет отлаживать JavaScript в новом браузере Microsoft Edge Insider для проектов ASP.NET и ASP.NET Core. Для этого просто установите браузер, установите точку останова в JavaScript приложении и начните сеанс отладки. Visual Studio запустит новое окно браузера с включенной отладкой, что позволит вам шагать по коду JavaScript в Visual Studio (см. картинку выше).

Улучшения помощников
- «По просьбам трудящихся» возвращена команда Sort Usings, и она отделена Remove Usings. Sort Usings можно найти в меню Edit > IntelliSense.
- Добавлена возможность преобразовывать операторы switch в выражения. Поскольку выражения-переключатели являются новой функцией C# 8.0, необходимо убедиться, что вы используете самую последнюю версию языка. Поместите курсор на ключевое слово switch, нажмите Ctrl+., в выпадающем меню Quick Actions and Refactorings выберите Convert switch statement to expression.

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

Источник: https://devblogs.microsoft.com/visualstudio/visual-studio-2019-version-16-2-preview-2/

День сто сорок третий. #ЗаметкиНаПолях
Коллекции в C#
3. Стек
Стек - это тип коллекции с поведением «последний пришел - первым вышел» (LIFO). Мы часто используем стеки в сценариях, где нам нужно предоставить пользователю способ вернуться назад. Подумайте о своем браузере. Когда вы переходите на разные веб-сайты, эти адреса, которые вы посещаете, помещаются в стек. Затем, когда вы нажимаете кнопку «Назад», элемент в стеке (который представляет текущий адрес в браузере) извлекается, и теперь мы можем получить последний адрес, который вы посетили, из элемента в стеке. Функция отмены в приложениях также реализована с использованием стека.
Использование стека:

var stack = new Stack<string>();
// Размещение элемента в стеке
stack.Push("http://www.google.com");
// Проверка вхождения элемента 
var contains = stack.Contains("http://www.google.com");
// Извлечение элемента из вершины стека 
var top = stack.Pop();
// Просмотр элемента из вершины стека без извлечения 
var top = stack.Peek();
// Количество элементов 
var count = stack.Count;
// Очистка 
stack.Clear();

Внутренне стек реализован с использованием массива. Поскольку массивы в C# имеют фиксированный размер, когда вы помещаете элементы в стек, может потребоваться увеличить его емкость путем выделения большего массива и копирования существующих элементов в новый массив. Если выделения не требуется, операция Push выполняется за время O(1); в противном случае, при условии, что в стеке есть n элементов, все эти элементы необходимо скопировать в новый массив. Это приводит к выполнению операции за время O(n). Pop – за время O(1). Contains - O(n).

Источник: https://programmingwithmosh.com/net/csharp-collections/

День сто сорок четвёртый. #ЗаметкиНаПолях
Коллекции в C#
4. Очередь
Очередь представляет коллекцию с поведением «первым пришел - первым обслужен» (FIFO). Очереди используются, когда нужно обрабатывать элементы по мере их поступления.
Queue<T> реализует обобщённую очередь в виде циклического массива. Объекты добавляются с одного конца и извлекаются с другого. Очереди и стеки полезны, когда вам нужно временное хранилище информации (когда вы можете отказаться от элемента после получения его значения). Используйте очередь, если вам нужен доступ к информации в том же порядке, в котором она хранится в коллекции.
Основные операции:
- Enqueue: добавление элемента в конец очереди;
- Dequeue: извлечение элемента из начала очереди;
- Peek: просмотр элемента из начала очереди без извлечения.
Ёмкость Queue<T> - это количество элементов, которые она может содержать. По мере добавления элементов ёмкость автоматически увеличивается при необходимости путем перераспределения внутреннего массива. Емкость можно уменьшить, вызвав метод TrimExcess.
Queue<T> допускает значение NULL для ссылочных типов и допускает дублирование элементов.

Использование:

var queue = new Queue<string>();
// добавление
queue.Enqueue("transaction1");
// проверка вхождения элемента
var contains = queue.Contains("transaction1");
// извлечение
var front = queue.Dequeue();
// просмотр первого элемента
var top = queue.Peek();
// очистка очереди 
queue.Clear();
// количество элементов
var count = queue.Count;

Если нужен одновременный доступ к коллекции из нескольких потоков,
используются ConcurrentQueue<T> для очереди или ConcurrentStack<T> для стека.

Источники:
- https://programmingwithmosh.com/net/csharp-collections/
- https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.queue

День сто сорок пятый. #ЗаметкиНаПолях
Коллекции в C#
5. Битовый массив BitArray
Битовый массив управляет компактным массивом значений битов, которые представлены как логические значения, где true указывает, что бит включен (1), а false указывает, что бит выключен (0).
Класс BitArray - это класс коллекции, емкость которого всегда равна количеству. Элементы добавляются в BitArray путем увеличения свойства Length; удаляются уменьшением свойства Length.

// Инициализация (все значения false)
var ba1 = new BitArray(16);
// Инициализация массивом байтов
// 16 элементов: 1й байт - 0-7, 2й байт - 8-15
byte[] bt = new byte[] { 10, 64 };
var ba2 = new BitArray(bt);
// Количество элементов (16)
var cnt = ba2.Length;
// Установка отдельного значения
ba1[13] = true;

Класс BitArray предоставляет методы, которых нет в других коллекциях, в том числе те, которые позволяют одновременно изменять несколько элементов с помощью фильтров, таких как And, Or, Xor, Not и SetAll:

// изменение значений на противоположные
ba1.Not();
// Побитовое И (изменяет ba1)
ba1.And(ba2);
// Побитовое ИЛИ (изменяет ba1)
ba1.Or(ba2);
// Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ (изменяет ba1)
ba1.Xor(ba2);
// Установка всех значений
ba1.SetAll(true);

Источники:
- https://docs.microsoft.com/ru-ru/dotnet/api/system.collections.bitarray

День сто сорок шестой. #ЗаметкиНаПолях
Коллекции в C#
6. Сортировка коллекций
В .Net реализованы следующие основные типы отсортированных коллекций:
1. SortedSet<T>
Поддерживает отсортированный порядок, не влияя на производительность вставки и удаления. Повторяющиеся элементы не допускаются. Изменение отсортированных значений существующих элементов не поддерживается и может привести к неожиданному поведению. Потокобезопасная версия - ImmutableSortedSet<T>.

2. SortedList<TKey,TValue> и SortedDictionary<TKey,TValue>
SortedList<TKey, TValue> - это массив пар ключ/значение с поиском за время O(log n). В этом он похож на SortedDictionary<TKey, TValue>. Два класса имеют похожие объектные модели, и оба имеют время извлечения O(log n). Различаются они в использовании памяти и скорости вставки и удаления:
- SortedList использует меньше памяти.
- SortedDictionary быстрее вставляет и удаляет несортированные данные (O(log n) против O(n) для SortedList).
- Если список заполняется сразу из отсортированных данных, SortedList работает быстрее.
SortedList поддерживает эффективный индексированный поиск ключей и значений через коллекции, возвращаемые свойствами Keys и Values. Нет необходимости повторно создавать списки при обращении к свойствам, поскольку они являются просто оболочками для внутренних массивов ключей и значений. В следующем коде показано использование индексатора свойства Values для извлечения значения из отсортированного списка строк:

string v = mySortedList.Values[3];

Элементы SortedList могут быть извлечены как объекты KeyValuePair<TKey, TValue>, для SortedDictionary – как KeyValuePair<TKey, TValue> или как необобщённые объекты DictionaryEntry.
Объекты ключей должны быть неизменяемыми, если они используются в качестве ключей в SortedList или SortedDictionary. Каждый ключ в должен быть уникальным, не нулевым. Значение может быть нулевым, если TValue - ссылочный тип.
SortedList и SortedDictionary требуют реализации компаратора для сортировки и выполнения сравнений. Компаратор по умолчанию Comparer<T>.Default проверяет, реализует ли тип ключа IComparable<T>, и использует эту реализацию, если она доступна. Если нет, он проверяет, реализует ли тип ключа IComparable. Если тип ключа не реализует ни один из этих интерфейсов, вы можете указать параметр-компаратор, реализующий IComparer<T>, в перегруженной версии конструктора.
Когда элементы добавляются в SortedList, емкость автоматически увеличивается по мере необходимости путем перераспределения внутреннего массива. Емкость можно уменьшить, вызвав TrimExcess или явно указав свойство Capacity. Уменьшение емкости перераспределяет память и копирует все элементы в SortedList.
Оператор foreach перебирает объекты типа элементов в коллекции. Поскольку элементы SortedList и SortedDictionary являются парами ключ/значение, foreach перебирает элементы KeyValuePair<TKey, TValue>:

foreach (KeyValuePair<int, string> kvp в sortedList)
{
  Console.WriteLine("{0} = {1}", kvp.Key, kvp.Value);
}

Кроме того, можно использовать метод Sort для несортированных списков:
- Sort(IComparer<T> comparer)
Cортирует все элементы, используя указанный компаратор.
- Sort(int index, int count, IComparer<T> comparer)
Cортирует элементы в диапазоне (count элементов, начиная с index), используя указанный компаратор.
- Sort()
Сортирует все элементы, используя компаратор по умолчанию.
- Sort(Comparison<T> cmp)
Сортирует все элементы списка, используя делегат сравнения. Делегат сравнения вида int Comparison<in T>(T x, T y) должен возвращать значение меньше 0, если x<y, больше 0, если x>y и 0, если x=y.
Например:

var list = new List<int>{2,4,3,1};
// сортировка по возрастанию (по умолчанию)
list.Sort(); // 1,2,3,4
// используем лямбда-выражение для сортировки по убыванию
list.Sort((x,y) => y-x); // 4,3,2,1

Источник: https://docs.microsoft.com/ru-ru/dotnet/api/system.collections.generic

День сто сорок седьмой. #ВопросыНаСобеседовании
Самые часто задаваемые вопросы на собеседовании по .NET
1. Что такое .NET Framework?
.NET Framework - это набор многократно используемых библиотек (коллекций классов), предоставляемый Microsoft для использования в других приложениях .Net, а также для разработки, создания и развертывания многих типов приложений на платформе Windows, включая:
- Консольные приложения
- Приложения Windows Forms
- Приложения Windows Presentation Foundation (WPF)
- Веб-приложения
- Веб-сервисы
- Службы Windows
- Сервис-ориентированные приложения с использованием Windows Communications Foundation (WCF)
- Приложения с поддержкой рабочих процессов, использующие Windows Workflow Foundation (WF)

Работает в основном на операционной системе Microsoft Windows.

Компиляция программы .NET
Что на самом деле происходит, когда мы компилируем программу .NET?
- Созданный exe-файл не содержит исполняемого кода, это код на MicroSoft Intermediate Language (MSIL).
- Когда вы запускаете EXE-файл, запускается общеязыковая среда выполнения (Common Language Runtime или CLR) и инструкции IL выполняются CLR на машинном языке.
- CLR предлагает компилятор Just In Time (JIT), который переводит IL на машинный язык.
См. рисунок ниже.

Таким образом, процесс программирования проходит как:
- Программа пишется на C#, VB.Net и других языках.
- Код компилируется в IL с помощью компилятора языка (csc.exe, vbc.exe и т.д.).
- При запуске программы на IL, запускается CLR, которая, используя JIT, преобразует IL в машинный код по мере выполнения программы.

Ядро .NET Framework
- Сервисы Приложений
- Библиотеки базовых классов
- Общеязыковая Среда Выполнения (Common Language Runtime)
- Сборщик Мусора (Garbage Collector)
- Общая Система Типов (Common Type System)
- Общеязыковая Спецификация (Common Language Specification)

Источник: https://www.c-sharpcorner.com

День сто сорок восьмой. #ВопросыНаСобеседовании
Самые часто задаваемые вопросы на собеседовании по .NET
2. Что такое CLR?
CLR (Common Language Runtime) – Общеязыковая Среда Исполнения. Она работает как слой между операционной системой и приложениями, написанными на языках .Net, которые соответствуют Общеязыковой Спецификации (CLS). Основной функцией CLR является преобразование управляемого кода в машинный код и последующее выполнение программы. Управляемый код компилируется только тогда, когда это необходимо, то есть он преобразует соответствующие инструкции при вызове каждой функции. Компиляция JIT позволяет преобразовать промежуточный язык (MSIL) в машинный код по требованию во время выполнения приложения.
Во время выполнения приложения .Net управление переходит к операционной системе, она создает процесс для загрузки CLR. Программа, используемая операционной системой для загрузки CLR, называется средой выполнения, которая отличается в зависимости от типа приложения: настольное, веб-приложение и т.д.

Среда выполнения CLR имеет набор сервисов:
1. Распознаватель Сборок (Assembly Resolver)
Читает манифест приложения, определяет приватную или общую сборку, необходимую для выполнения приложения и передаёт запрос загрузчику сборок.
2. Загрузчик Сборок (Assembly Loader)
Загружает сборку в процесс приложения на основе инструкций распознавателя сборок.
3. Инспектор Типов (Type Checker)
Проверяет типы, используемые в приложении, на соответствие со стандартами CTS или CLS, поддерживаемыми CLR, что обеспечивает безопасность типов.
4. Маршаллер COM (COM marshaller)
Обеспечивает связь с COM-компонентами.
5. Диспетчер Отладки (Debug Manager)
Активирует утилиту отладчика для поддержки построчного выполнения. Разработчик может вносить изменения, не прерывая отладки приложения.
6. Поддержка Потоков (Thread Support)
Управляет потоками выполнения в процессе приложения.
7. IL Компилятор (IL to Native compiler)
Компилятор IL в машинный язык называется JIT-компилятором (Just-In-Time). Он преобразует IL-код в машинный код операционной системы во время выполнения.
8. Менеджер Исключений (Exception Manager)
Обрабатывает исключения, генерируемые приложением, выполняя блоки catch, либо при отсутствии обработчика завершает работу приложения.
9. Сборщик Мусора (Garbage Collector)
Освобождает память от неиспользуемых объектов, это обеспечивает автоматическое управление памятью.

Источник: https://www.c-sharpcorner.com

День сто сорок девятый. #ЗаметкиНаПолях
Отражение. Начало
Отражение предоставляет объекты (типа Type), которые описывают сборки, модули и типы. Используется для динамического создания экземпляра типа, привязки типа к существующему объекту или получения типа из существующего объекта и вызова его методов или доступа к его полям и свойствам. Если вы используете атрибуты в своем коде, отражение позволяет вам получить к ним доступ.
Вот простой пример отражения с использованием статического метода GetType, унаследованного всеми типами из базового класса Object, для получения типа переменной:

// Получение информации о типе 
int i = 42;  
System.Type type = i.GetType();  
System.Console.WriteLine(type);  
// Вывод: System.Int32

// Получение информации о сборке 
System.Reflection.Assembly info = typeof(System.Int32).Assembly;  
System.Console.WriteLine(info);  
// Вывод:
// mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Сценарии использования:
- Получение доступа к атрибутам в метаданных программы.
- Изучение и создание экземпляров типов в сборке.
- Создание новых типов во время выполнения. Используются классы из System.Reflection.Emit.
- Позднее связывание, доступ к методам типов, созданных во время выполнения.

Продолжение следует…

Источник: https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/concepts/reflection

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

Классы System.Reflection:
1. Assembly - распознавание и загрузка сборки, загрузка модулей из манифеста сборки, поиск типа в этой сборке и создание его экземпляров.
2. Module - обнаружение информации, такой как сборка, содержащая модуль и классы в модуле, получение всех глобальных и неглобальные методов, определенных в модуле.
3. ConstructorInfo - обнаружение имени, параметров, модификаторов доступа и подробностей реализации конструктора. Методы GetConstructors и GetConstructor используются для вызова определенного конструктора.
4. MethodInfo - обнаружение имени, типа возвращаемого значения, параметров, модификаторов доступа и подробностей реализации метода. Методы GetMethods и GetMethod используются для вызова определенного метода.
5. FieldInfo – обнаружение имени, модификаторов доступа и подробностей реализации поля, а также для получения или установки значений поля.
6. EventInfo – обнаружение имени, типа данных обработчика событий, пользовательских атрибутов, и т.п. события, а также для добавления или удаления обработчиков событий.
7. PropertyInfo - обнаружение имени, типа данных и состояния свойства, а также для получения или установки значений свойства.
8. ParameterInfo - обнаружение имени параметра, типа данных, является ли параметр входным или выходным, а также положения параметра в сигнатуре метода.
9. CustomAttributeData - обнаружение информации о пользовательских атрибутах, позволяет исследовать атрибуты, не создавая их экземпляры.

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

Продолжение следует…

Источник: https://docs.microsoft.com/ru-ru/dotnet/framework/reflection-and-codedom/reflection

День сто пятьдесят первый. #ЗаметкиНаПолях
Отражение. Окончание
Небольшое приложение для демонстрации возможностей отражения. А заодно протестировать Git в Visual Studio и сервис Azure DevOps (о нём позже). Сразу оговорюсь, с Git практически не работал, по работе больше используем SVN, поэтому, возможно, репозиторий не оформлен по всем канонам. Не судите строго.
В общем, небольшая консольная утилита анализирует сборки .Net в файлах, помещаемых в папку files и выводит информацию о сборке, классах в сборке и членах классов. Информация выводится в консоль и в лог-файл в папке logs.
Если анализируемая сборка ссылается на другие сборки, то необходимые сборки должны быть помещены в папку libs.

Исходный код: https://dev.azure.com/sbenzenko/NetDeveloper/_git/Reflection

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

Источник: Джеффри Рихтер “CLR via C#”. 3-е изд. – СПб.: Питер, 2012. Глава 23.

День сто пятьдесят второй. #МоиИнструменты
Azure DevOps
Этот пост серии Мои Инструменты будет отличаться от остальных, поскольку этим инструментом я только начал пользоваться. То есть, не могу в полной мере назвать его своим. Как обещал, рассказываю про Microsoft Azure DevOps. Его можно найти здесь https://visualstudio.microsoft.com/ru/team-services/
Как видно из ссылки, это сервис больше для командной разработки. Но и индивидуальные разработчики могут найти много полезного. Во-первых, это бесплатный репозиторий Git. Можно создавать как публичные, так и приватные репозитории.
Система создана для управления вашими проектами. Создаёте проект, система сразу же создаёт для него репозиторий, ссылку на который вы можете скопировать, либо (что очень круто) выполнить Git Clone сразу в вашу любимую IDE (Visual Studio, VS Code, PHP Storm, Eclipse, тысячи их…(с)). Соответственно вся информация о репозитории(-ях): Commits, Pushes, Tags и т.п. - тоже доступна на вкладке Repos.
На вкладке Boards доступны различные инструменты управления проектом: Agile, Scrum, вотэтовсё. Можно управлять рабочим процессом, создавать задания, назначать на них исполнителей и отслеживать выполнение. Кроме того, задания можно привязывать к коммитам Git и как в статистике коммитов, так и в статистике заданий, будет отображаться информация о том, какой коммит к какому заданию привязан.
На вкладке Test Plans можно управлять тестированием проекта. Например, указывать группе тестировщиков (или себе на будущее), как надо тестировать тот или иной функционал.
Вкладка Pipelines самая интересная. Позволяет управлять развёртыванием проекта. Например, можно настроить выполнение заданий при каждом коммите: автоматическую сборку проекта, выполнение автоматизированных тестов, выкладывание продакшн кода в облачный сервис и т.п. И если что-то из этого завершится неудачей, вы получите email и это будет отображено в описании проекта. Можно настраивать развёртывание нескольких версий приложения (версии для разработки, стейджинг и продакшн версии) по-разному.

В общем, система очень богатая и полезная. Здесь мы только «поцарапали её поверхность», как говорят у них.

Источник и подробности (на английском): https://www.youtube.com/watch?v=H-R2bCXfz8I