День сороковой. #CodeComplete
Командная работа

Важно:
1. По статистике код в среднем «переживает» до 10 поколений поддерживающих его программистов.
2. Программисты, поддерживающие код, проводят 50-60% своего времени, читая код.

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

Помимо собственно грамотно написанного кода, его пониманию способствуют комментарии.

Виды комментариев:
1. Повторяющие код. Такие комментарии не нужны, их необходимо убрать.

// добавляем 1 к i
i = i + 1;

2. Объясняющие код.

// i обозначает номер клиента
i = i + 1;

Замените i на какое-нибудь значимое имя, например, customer, и уберите такие комментарии.
3. Отмечающие место в коде.

return null; // *** НЕ СДЕЛАНО!!! ***

Замените такой комментарий на стандартный блок TODO.
4. Комментарии исправлений. Переместите такие комментарии в систему контроля версий.

for i = 1 to maxElements-1 //исправлена ошибка №1234

5. Кратко объясняющие суть блока кода. Важно поддерживать актуальность таких комментариев!
6. Описывающие предназначение кода. Используйте комментарии, близкие к реальному миру, а не к техническим подробностям реализации, например:

// получаем информацию о работнике

вместо

// обновляем объект employeeRecord

7. Содержащие информацию, которая не может быть представлена в коде. Например, авторские права, Javadoc, ссылки на онлайн ресурсы и т.п.
8. Содержащие краткий обзор или вводную информацию для модуля или библиотеки.

День сорок первый. #ЗаметкиНаПолях
Nullable-типы
Иногда бывают ситуации, когда необходимо чтобы тип значений мог принимать null, и это можно сделать, указав знак вопроса ? после имени типа, при объявлении переменной:

int? a = 5;
double? b = null;
bool? c = false;

Nullable-типы могут пригодиться при работе с базой данных. Некоторые поля таблицы базы данных могут принимать значение null.
Запись ? является упрощенной формой использования структуры System.Nullable<T>:

[System.Serializable]
public struct Nullable<T> where T : struct

Следующие виды определения переменных будут эквивалентны предыдущим:

Nullable<int> a = 5;
Nullable<double> b = null;
Nullable<bool> c = false;

Операторы
Любые операторы, которые определены для значимых типов, также могут быть использованы для nullable-типов. Эти операторы вернут null, если один или оба операнда null. В противном случае операторы используют содержащиеся значения для расчёта результата. Например:

int? a = 10;
int? b = null;
int? c = 10;
a++;        // a = 11
a = a * c;  // a = 110
a = a + b;  // a = null

Для операторов сравнения (<, >, <=, >=), если один или оба операнда null, результатом будет ложь. Не рассчитывайте на то, что, если определённое сравнение (например, <=) возвращает ложь, то обратное сравнение (>) вернёт правду! Например, 10:
- не больше и не равно null,
- также и не меньше null.

Оператор ?? (null-объединение)
Оператор null-объединения ?? похож на тернарный оператор. Он имеет следующую структуру:
[операнд1] ?? [операнд2];
?? возвращает операнд1, если тот не равен значению null, иначе возвращает операнд2.

int? a = 1;
int? b = null;
Console.WriteLine(a ?? 3); // 1
Console.WriteLine(b ?? 3); // 3

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

Источники:
- https://mycsharp.ru/post/47/2014_09_30_znachenie_null_nullable-tipy_operator___.html
- https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/nullable-types/using-nullable-types

День сорок второй. #TipsAndTricks
2. Сохраняйте полный стек вызовов при выбросе исключения
Если в блоке catch программы C# выбрасывается исключение при помощи конструкции

catch (Exception ex)
{
  throw ex;
}

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

static void Main(string[] args)
{
  try
  {
    Method2();
  }
  catch (Exception ex)
  {
    Console.WriteLine(ex.Message);
    Console.Write(ex.StackTrace.ToString());
    Console.ReadKey();
  }
}

private static void Method2()
{
  try
  {
    Method1();
  }
  catch (Exception ex)
  {
    //throw ex очищает стек вызовов, идущий из Method1
    // и добавляет в него только собственную запись 
    // перед передачей вызывающему методу (Main)
    throw ex;
  }
}

private static void Method1()
{
  try
  {
    throw new Exception("Исключение внутри Method1");
  }
  catch (Exception)
  {
    throw;
  }
}

Код выводит:

Исключение внутри Method1
   at Program.Method2() in …\ConsoleApp1\Program.cs:line 30
   at Program.Main(String[] args) in …\ConsoleApp1\Program.cs:line 9

Чтобы сохранить полный стек вызовов, используйте throw; без аргументов. При этом вы можете обработать переменную ex в блоке catch. Например, сделать запись в лог:

catch (Exception ex)
{
  Console.WriteLine("Лог в Method2: {0}", ex.Message);
  throw;
}

Такой код выведет:

Лог в Method2: Исключение внутри Method1
Исключение внутри Method1
   at Program.Method1() in …\ConsoleApp1\Program.cs:line 39
   at Program.Method2() in …\ConsoleApp1\Program.cs:line 23
   at Program.Main(String[] args) in …\ConsoleApp1\Program.cs:line 9

Источник: https://stackoverflow.com/questions/730250/is-there-a-difference-between-throw-and-throw-ex

День сорок третий. #ЗаметкиНаПолях
Битовые флаги
Тип перечисления можно использовать для определения битовых флагов, благодаря чему экземпляр типа перечисления может хранить любую комбинацию значений, определенных в списке перечислителя.
Чтобы создать перечисление битовых флагов, нужно:
1. Добавить атрибут System.FlagsAttribute.
2. Определить значения так, чтобы для них могли выполняться битовые операции AND, OR, NOT и XOR.
3. Добавить именованную константу с нулевым значением, что означает "флаги не установлены" (не задавайте флагу нулевое значение, если оно не означает "флаги не установлены").
В следующем примере у перечисления Days имеется атрибут Flags, и каждому значению присваивается следующая степень числа 2:

[Flags]
enum Days
{
    None = 0x0,
    Sunday = 0x1,
    Monday = 0x2,
    Tuesday = 0x4,
    Wednesday = 0x8,
    Thursday = 0x10,
    Friday = 0x20,
    Saturday = 0x40
}

Чтобы установить несколько флагов перечисления, используйте битовый оператор OR:

// Устанавливаем два флага с помощью битового OR
meetingDays = Days.Tuesday | Days.Thursday;

// Добавляем флаг с помощью битового OR
meetingDays = meetingDays | Days.Friday;

Console.WriteLine("Дни встречи: {0}", meetingDays);
// Вывод: Дни встречи: Tuesday, Thursday, Friday

// Снимаем флаг с помощью битового XOR
meetingDays = meetingDays ^ Days.Tuesday;
Console.WriteLine("Дни встречи: {0}", meetingDays);
// Вывод: Дни встречи: Thursday, Friday

Чтобы определить, установлен ли конкретный флаг, используйте битовый оператор AND:

// Проверка, установлен ли флаг с помощью битового AND
bool test = (meetingDays & Days.Thursday) == Days.Thursday;
Console.WriteLine("Thursday – это {0}день встречи.", test == true ? "" : "не ");
// Вывод: Thursday – это день встречи.

Кроме того, можно получить числовое значение строки, содержащей разделённые запятыми идентификаторы флагов, с помощью методов Parse или TryParse типа Enum:

Days d = (Days)Enum.Parse(typeof(Days), "monday,sunday", true);
Console.WriteLine("Дни встречи: {0}", d);
// Вывод: Дни встречи: Sunday, Monday
        
if (Enum.TryParse("friday,sunday", true, out d))
  Console.WriteLine("Дни встречи: {0}", d);
// Вывод: Дни встречи: Sunday, Monday

При этом:
- значения могут быть неупорядоченными, метод Parse упорядочивает их;
- параметр ignoreCase позволяет игнорировать регистр символов;
- метод TryParse на самом деле обобщённый (TryParse<Days>), но параметр типа можно не указывать, он определяется по типу последнего out параметра.

Также для парсинга можно использовать числовое значение (сумму числовых значений флагов):

if (Enum.TryParse("108", true, out d))
  Console.WriteLine("Дни встречи: {0}", d);
// Вывод: Дни встречи: Tuesday, Wednesday, Friday, Saturday

Источники:
- Джеффри Рихтер “CLR via C#”. 3-е изд. – СПб.: Питер, 2012. Глава 15.
- https://docs.microsoft.com/ru-ru/dotnet/csharp/programming-guide/enumeration-types

День сорок четвёртый. #TipsAndTricks
3. Оператор безопасной навигации
Вас ведь тоже бесит постоянно возникающее NullReferenceException, когда происходит обращение к неинициализированному объекту? Чаще всего null-исключение возникает из-за примерно следующего кода:

string name = null;
Console.WriteLine(name);

В большинстве случаев компилятор не позволит вам продолжить, пока вы не исправите код. Но если вы каким-то образом заставите компилятор думать, что переменная имеет значение, а во время выполнения его не окажется, будет выброшено NullReferenceException. Чтобы избежать этого, вы можете сделать следующее:

string name = null;
// Некоторый код
if(name != null) {
   Console.WriteLine(name);
}

Это безопасная проверка, которая позволяет убедиться, что значение переменной доступно при её вызове.
Однако в C#6 появился другой способ обойти эту ошибку. Допустим, у вас есть база данных людей, и вы хотите получить данные о трудоустройстве человека, но такие данные отсутствуют, а вы хотите получить название компании-работодателя:

var company = DbHelper.PeopleTable.Find(x => x.id == id).FirstOrDefault().EmploymentHistory.CompanyName;

Если вы попытаетесь это сделать, возникнет ошибка. Как только в цепочке вызовов встречается null, всё пропало. В C#6 появился способ обойти это, используя оператор безопасной навигации после значений или полей, которые могут быть null. Вот так:

var company = DbHelper?.PeopleTable?.Find(x => x.id == id)?.FirstOrDefault()?.EmploymentHistory?.CompanyName;

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

if(company != null) {
   // Дальнейшая обработка
}

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

Источник: https://www.pluralsight.com/guides/tips-for-writing-better-c-code

День сорок пятый. #TipsAndTricks
4. Добавление методов к перечислениям
Определить метод как часть перечислимого типа напрямую невозможно. Однако это ограничение можно обойти при помощи методов расширения. Рассмотрим упоминавшееся ранее перечисление дней недели (см. день сорок третий):

[Flags]
public enum Days
{
  None = 0x0,
  Sunday = 0x1,
  Monday = 0x2,
  Tuesday = 0x4,
  Wednesday = 0x8,
  Thursday = 0x10,
  Friday = 0x20,
  Saturday = 0x40
}

Для добавления методов к перечислению нужно определить статический класс с методами расширения:

static class DaysExtensions
{
  static Days GetWorkdays(this Days days)
  {
    // 62 – сумма значений элементов от Monday до Friday
    Enum.TryParse("62", true, out days);
    return days;
  }

  public static Days GetWeekends(this Days days)
  {
    // 65 – сумма значений элементов Sunday и Saturday
    Enum.TryParse("65", true, out days);
    return days;
  }
}

Теперь эти методы можно использовать, вызывая их из экземпляра перечисления:
var d = Days.None;
Console.WriteLine("Рабочие дни: {0}", d.GetWorkdays());
Console.WriteLine("Выходные: {0}", d.GetWeekends());

// Вывод:
// Рабочие дни: Monday, Tuesday, Wednesday, Thursday, Friday
// Выходные: Sunday, Saturday

День сорок шестой. #ЗаметкиНаПолях
Кортежи
C# предоставляет богатый синтаксис классов и структур, который можно использовать для различных целей проектирования. Но иногда даже такой богатый синтаксис требует дополнительной работы, которая не приносит особой пользы. Вам может потребоваться написать метод, который использует простую структуру, содержащую более одного элемента данных. Для поддержки таких сценариев в язык C# были добавлены кортежи. Кортежи – это простые структуры данных, содержащие несколько полей. Поля не проверяются, и вы не можете определить ваши методы для кортежа.
До С# 7 кортежи были отдельным классом, и работать с ними было не так удобно. В 7й версии языка появился упрощённый синтаксис. Вы можете создать кортеж, присвоив значение каждому его члену:

var letters = ("a", "b");

Обращаться к полям кортежа можно по именам Item1, Item2 и т.д. по порядку. Также им можно задать имена. Для этого есть два способа.
- Справа от оператора присваивания:

var alphabetStart = (Alpha: "a", Beta: "b");

- И слева от него:

(string Alpha, string Beta) namedLetters = ("a", "b");

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

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

private static (int Max, int Min) Range(IEnumerable<int> numbers)
{
  int min = int.MaxValue;
  int max = int.MinValue;
  foreach(var n in numbers)
  {
    min = (n < min) ? n : min;
    max = (n > max) ? n : max;
  }
  return (max, min);
}

Объявление этого метода предоставляет имена полей возвращаемого кортежа. При вызове метода возвращаемым типом является кортеж, имена полей которого Max и Min:

var range = Range(numbers);
Console.WriteLine(range.Min);

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

(int max, int min) = Range(numbers);
Console.WriteLine($"{min} - {max}");

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

Источник: https://docs.microsoft.com/ru-ru/dotnet/csharp/whats-new/csharp-7#tuples

День сорок седьмой. #ЗаметкиНаПолях
Приведение типов или Convert.To()
Несмотря на то, что эти операции могут казаться эквивалентными, они совершенно разные по целям.
Приведение типа – это действие по изменению объекта из одного типа данных в другой. Это достаточно общее определение, и в некотором смысле оно похоже на конвертацию, поскольку приведение типа часто имеет тот же синтаксис, что и конвертация. Поэтому возникает вопрос, когда достаточно приведения типа (неявного или явного), а когда вам придётся использовать более явную конвертацию.

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

Неявные приведения типов
В C# приведение типа происходит неявно, когда вы не теряете информацию (заметьте, что эта проверка происходит на уровне типов, а не на уровне реальных значений переменных). Например, для примитивных типов:

int tinyInteger = 10;
long bigInteger = tinyInteger;
float tinyReal = 10.0f;
double bigReal = tinyReal;

Эти приведения неявны, поскольку при этом вы не теряете информацию (вы расширяете тип). В обратную сторону неявное приведение невозможно, потому что вне зависимости от реальных значений (они проверяются только во время выполнения) при приведении вы можете потерять часть данных. Например, следующий код не скомпилируется, потому что тип double может содержать значения, не представленные в типе float:

double bigReal = Double.MaxValue;
float tinyReal = bigReal;

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

string text = "123";
IFormattable formattable = text;
NotSupportedException derivedException = new NotSupportedException();
Exception baseException = derivedException;

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

Явные приведения типов
Приведение типа явно, когда оно не может быть выполнено неявно компилятором, и вам нужно использовать оператор приведения типа. Обычно это значит, что:
1. Вы можете потерять информацию или данные.
2. Преобразование может завершиться неудачей (поскольку вы не можете привести один тип к другому).
Явное преобразование подразумевает, что вы понимаете эти угрозы.
Для примитивных типов:

double precise = Math.Cos(Math.PI * 1.23456) / Math.Sin(1.23456);
float coarse = (float)precise;
float epsilon = (float)Double.Epsilon;

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

float max = (float)Double.MaxValue;

А следующее преобразование не скомпилируется, поскольку компилятор не умеет преобразовывать текст в число. Текст может содержать любые символы, не только цифры, поэтому в C# это недопустимо (хотя может быть допустимо в других языках):

string text = "123";
double value = (double)text;

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

string text = (string)AppDomain.Current;
Exception exception = (Exception)"abc";

Следующий код скомпилируется, но он может привести к ошибке времени выполнения InvalidCastException в зависимости от реального типа объекта:

object obj = GetNextObjectFromInput();
string text = (string)obj;
Exception exception = (Exception)obj;

Преобразования
Поэтому, отбрасывая некоторые незначительные нюансы реализации типа Convert или интерфейса IConvertible, в случае приведения типа в C# вы говорите компилятору:
«Доверься мне, этот тип можно привести к этому типу. Даже если ты этого не знаешь сейчас, позволь мне это сделать и всё получится.»
или
«Не беспокойся, мне неважно, если что-то потеряется при приведении.»
Для любого другого приведения, когда требуется более явная операция, требуется преобразование значения. Например, для приведения из string в double может потребоваться парсинг. Преобразование в строку, например, всегда возможно, (через метод ToString()), хотя может означать что-то другое, нежели то, что вы ожидаете.

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

Подводя итог, когда можно использовать явное приведение типов:
1. Приведение между базовыми типами.
2. Приведение от объекта в другой тип (может включать распаковку).
3. Приведение от производного в базовый класс (или в реализованный интерфейс).
4. Преобразование из одного типа к другому через специальные операторы преобразования.
Только первый из этих вариантов может быть реализован через тип Convert. Для остальных случаев у вас нет другого выбора, кроме явного приведения типа.

Когда можно использовать тип Convert:
1. Преобразование из одного базового типа в другой (с некоторыми ограничениями).
2. Преобразование из типа, реализующего интерфейс IConvertible в любой другой (поддерживаемый) тип.
3. Преобразования массива битов в строку и наоборот.

Заключение
По моему мнению, Convert должен использоваться во всех случаях, когда вы знаете, что преобразование может завершиться неудачей, даже если оно может быть выполнено с помощью приведения типов. Это даёт понять читающим ваш код ваши намерения и что вы знаете, что преобразование может завершиться неудачей. Для остальных случаев используйте приведение типа, т.к. нет выбора. Но если доступен другой метод (Parse, TryParse), я советую его использовать.

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

double real = 1.6;
int castedInteger = (int)real; // 1
int convertedInteger = Convert.ToInt32(real); // 2

Приведение типа (ожидаемо) отсекает дробную часть, а Convert осуществляет округление до ближайшего целого (а это может стать неожиданностью). Каждое преобразование может отличаться от приведения типа, поэтому единого правила для всех случаев нет. Лучше для каждого случая проконсультироваться с MSDN.

Источник: https://stackoverflow.com/questions/15394032/difference-between-casting-and-using-the-convert-to-method

День сорок восьмой. #TipsAndTricks
5. IntelliCode для Visual Studio
IntelliCode сохраняет ваше время, выбирая в качестве подсказки для автозаполнения то, что вы скорее всего будете использовать. Рекомендации IntelliCode основаны на тысячах проектов с открытым кодом на GitHub. При сочетании с контекстом вашего кода список подсказок теперь нацелен на наиболее используемые варианты. В результате вместо того, чтобы искать и прокручивать отсортированный список, вы получаете предложения наиболее вероятных вариантов в самом начале, как только начинаете печатать. При вводе члена класса вы заметите рекомендации IntelliCode, отмеченные звёздочкой (см. рисунок). Скачайте IntelliCode для VisualStudio здесь: https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.VSIntelliCode

Источник: https://devblogs.microsoft.com/visualstudio/argument-completion-made-easy-with-visual-studio-intellicode/

День сорок девятый. #ЗаметкиНаПолях
Деконструкция
Начиная с C# 7.0, вы можете извлекать несколько элементов из кортежа или несколько значений полей, свойств из объекта в одной операции деконструкции. При этом вы присваиваете значения полей кортежа или членов объекта отдельным переменным.
Деконструкция кортежа
Синтаксис деконструкции кортежа похож на синтаксис его определения (см. день сорок шестой). Допустим, есть метод QueryCityData, возвращающий для заданного города название, численность населения и площадь города.
Есть три варианта деконструкции:
1. Явно определить типы переменных

(string city, int population, double area) = QueryCityData("New York City");

2. Использовать ключевое слово var вне скобок для всех переменных:

var (city, population, area) = QueryCityData("New York City");

3. Использовать var любой или всех переменных:

(string city, var population, var area) = QueryCityData("New York City");

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

string city = "Raleigh";
int population = 458880;
double area = 144.8;
(city, population, area) = QueryCityData("New York City");

Заметьте:
- вы не можете объявить определённый тип вне скобок, даже если все поля кортежа одного типа;
- вы обязаны присвоить каждое поле массива переменной;
- вы не можете смешивать объявления переменных с использованием ранее объявленных переменных.
Если значения каких-либо полей кортежа вам не нужны, вы можете использовать специальный символ пустой переменной "_". Например, если из примера выше нам нужно получить только население города:

var (_, population, _) = QueryCityData("New York City");

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

public void Deconstruct(out string fname, out string mname, out string lname)

Произвести деконструкцию экземпляра класса Person, присвоенного переменной p, можно следующим образом:

var (fName, mName, lName) = p;

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

Источник: https://docs.microsoft.com/ru-ru/dotnet/csharp/deconstruct

День пятидесятый. #ЗаметкиНаПолях
Управление цепочками делегатов
В C# можно создавать и управлять цепочками делегатов при помощи операторов += и -=. Цепочку делегатов можно вызвать так же, как и единичный делегат. При этом будут вызваны все делегаты цепочки по очереди. Это достаточно удобно и подходит для большинства сценариев. Однако у этого метода есть ряд ограничений. Например, сохраняется только последнее из возвращаемых значений, возвращаемых методами. Получить остальные значения нельзя. Кроме того, если один из делегатов в цепочке выбрасывает исключение, работа цепочки останавливается.
В качестве альтернативы можно использовать метод GetInvokationList класса MulticastDelegate. Он возвращает массив ссылок на делегаты в цепочке. Следующий код безопасно выполняет делегаты из цепочки и сохраняет их возвращаемые значения:

private delegate string MyDelegate();

private static string Method1() => "Method1";
private static string Method2() => throw new Exception("Exception");
private static string Method3() => "Method3";

static void Main(string[] args)
{
  MyDelegate getResult = null;
  getResult += new MyDelegate(Method1);
  getResult += new MyDelegate(Method2);
  getResult += new MyDelegate(Method3);

  Console.WriteLine(GetAllResults(getResult));
}

private static string GetAllResults(MyDelegate result)
{
  if (result == null) return null;

  var report = new StringBuilder();
  var delegates = result.GetInvocationList();
  foreach (MyDelegate del in delegates)
  {
    try
    {
      //пытаемся выполнить метод, сохраняя его результат
      report.AppendFormat("{0}\n", del());
    }
    catch (Exception ex)
    {
      //обрабатываем ошибки метода
      //здесь component – класс владелец метода
      var component = del.Target;
      report.AppendFormat(
        " Ошибка при получении результата из метода {0}{1}: {2}\n",
        ((component == null) ? "" : component.GetType() + "."),
        del.Method.Name,
        ex.Message);
     }
  }

  return report.ToString();
}

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

День пятьдесят первый. #TipsAndTricks
Обучение IntelliCode
Недавно я рассказывал, как IntelliCode помогает вам писать код, выбирая наиболее подходящие подсказки на основе тысяч часто используемых библиотек в репозиториях GitHub. Вместо поиска и прокрутки отсортированного списка методов и свойств, вы получаете наиболее вероятные подсказки на основе вашего контекста программы.
Но что, если вы хотите получать такие подсказки на основе вашего набора библиотек? В C# вы можете позволить IntelliCode анализировать ваш собственный код и делиться результатами анализа внутри вашей команды. Установить зависимость IntelliCode от вашего кода, проанализировать его и поделиться результатами анализа с коллегами можно в течение нескольких минут. Это можно сделать в 3 простых шага:
1. Убедитесь, что у вас установлено расширение IntelliCode для
Visual Studio.
2. Создайте вашу модель кодовой базы, содержащую хорошие примеры использования желаемых библиотек классов. Помните, что качество подсказок, предлагаемых IntelliCode напрямую зависит от качества примеров, которые вы предоставите.
3. Поделитесь моделью с вашими коллегами, чтобы они смогли использовать рекомендации. Если вам потребуется обновить модель, например, после внесения существенных изменений в код, ваша команда автоматически получит последние изменения.
Подробности тут: https://docs.microsoft.com/en-us/visualstudio/intellicode/faq

Источник: https://devblogs.microsoft.com/visualstudio/code-more-scroll-less-with-visual-studio-intellicode/?utm_source=vs_developer_news&utm_medium=referral

День пятьдесят второй.
Сертификат Microsoft. Шаг 2
Поискал информацию о сдаче экзамена 70-483 «Programming in C#». Интересен был опыт людей, прошедших через это. На удивление статей не так много:
- Хабр https://habr.com/ru/post/245067/ (пятилетней давности).
- Блог на BlogSpot https://sonyks2007.blogspot.com/2014/02/mcp.html (пятилетней давности).
- Блог Андрея Акиньшина https://aakinshin.net/ru/posts/ms-mcp/ (пятилетней давности).
- Блог Дмитрия Маслова https://dmaslov.net/2018/09/06/exam-70-483/ (прошлогодний).
Остальное откровенный шлак, нисколько не полезный.

Что хочется отметить:
1. Авторы не раскрывают вопросов от слова совсем. На это ты подписываешь соглашение о неразглашении перед экзаменом.
2. Темы варьируются. Например, интересно было узнать, что в экзамен входят вопросы по шифрованию данных и управлению сборками. Не помню этих тем в списке на оф. сайте экзамена.
3. Книги по подготовке:
- Wouter de Kort, Exam Ref 70-483: Programming in C#
- Tiberiu Covaci, MCSD Certification Toolkit (Exam 70-483): Programming in C# (Wrox Programmer to Programmer)
Несколько человек написали, что не стоят своих денег, и если первая ещё более менее, то вторая содержит дикое количество ошибок и на неё вообще не стоит тратить время.
4. Варианты вопросов всё-таки есть вот на этом сайте: https://exambraindumps.com/70-483.html Там же можно сдать пробный экзамен. Не знаю, насколько легально это там размещено. Вопросы, говорят, что тоже не без ошибок. Посмотрим. Нужно выделить 1,5 часа на пробный тест.
Продолжаем подготовку…

PS: Хотел узнать, где поблизости можно пройти экзамен, т.к. из авторов один сдавал в Киеве, другой в Екатеринбурге, но кнопка "Запланировать экзамен" на сайте экзамена почему-то ведёт на пустую страницу.

День пятьдесят третий. #TipsAndTricks
Условие Прерывания на Исключении
В Visual Studio, вы можете использовать окно Exception Settings (Debug -> Windows -> Exception Settings) для управления исключениями: на каких исключениях среда должна прерываться, а также добавлять и удалять исключения. В Visual Studio 2017 появились дополнительные возможности управления. Вы можете установить условие прерывания.
Перейдите в окно Exception Settings и выберите типы исключений, для которых вы хотите задать условие. Выберите Редактировать Условие (Edit Condition). Здесь введите название модулей, в которых вы хотите, чтобы выполнение прерывалось. В настоящее время доступно только условие по имени модуля. Таким образом, при выполнении кода Visual Studio будет выбрасывать исключение CLR только при удовлетворении условию. Это полезно, когда вы хотите исключить срабатывание на известных ошибках какой-либо библиотеки (сторонней или находящейся в разработке).

Источник: https://dailydotnettips.com/

День пятьдесят четвёртый. #ЗаметкиНаПолях
Атрибуты. Начало
Атрибуты предоставляют мощный способ связывания метаданных с кодом.
Свойства атрибутов:
- Добавление метаданных в вашу программу, то есть информации о типах, определённых в программе. Все сборки .NET содержат набор метаданных, описывающих типы и члены типов, определённые в сборке. Можно добавлять свои атрибуты, создавая классы-наследники System.Attribute.
- Вы можете применить один или несколько атрибутов ко всей сборке, модулю или более мелким элементам программы, таким как классы и свойства.
- Атрибуты могут принимать аргументы так же, как методы и свойства.
- Ваша программа может получать доступ к своим метаданным или к метаданным других программ, используя рефлексию.

Использование атрибутов
Атрибуты могут применяться к практически любому объявлению: сборкам, модулям, типам, полям, возвращаемым значениям, методам, параметрам, свойствам, событиям, а также к полям и методам, создаваемым компилятором. Атрибуты указываются в квадратных скобках ([]) над объявлением сущности, к которой они применяются.
В этом примере атрибут SerializableAttribute используется для объявления характеристики класса:

[Serializable]
public class SampleClass
{
  // Объекты этого типа могут быть сериализованы.
}

По соглашению все имена атрибутов заканчиваются словом "Attribute", чтобы отделять их от других элементов библиотек .NET. Но его можно опускать при использовании атрибутов в коде. Например, [DllImport] эквивалентно [DllImportAttribute], но настоящее имя класса атрибута в библиотеке классов .NET Framework - DllImportAttribute.
Параметры атрибутов
Многие атрибуты имеют параметры, которые могут быть позиционными (неименованными) или именованными. Позиционные параметры обязаны указываться в определённом порядке и не могут быть опущены. Именованные параметры не обязательны и могут указываться в любом порядке. Позиционные параметры указываются первыми. Следующие три атрибута эквивалентны:

[DllImport("user32.dll")]
[DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]
[DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]

Первый параметр (имя DLL) позиционный и всегда идёт первым. Другие параметры именованные, оба по умолчанию имеют значение false, поэтому могут быть опущены. Позиционные параметры – это параметры конструктора атрибута, именованные соответствуют свойствам или полям атрибута.

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

using System;
using System.Reflection;
[assembly: AssemblyTitleAttribute("Production assembly 4")]
[module: CLSCompliant(true)]

А в этом примере атрибуты применяются к методу и к возвращаемому значению метода:

// по умолчанию: применяется к методу
[ValidatedContract]
int Method1() { return 0; }

// применяется к методу
[method: ValidatedContract]
int Method2() { return 0; }

// применяется к возвращаемому значению
[return: ValidatedContract]
int Method3() { return 0; }

Замечание. Некоторые целевые объекты обязательны для указания в атрибуте для разрешения конфликтов между неоднозначными целевыми объектами атрибута:
- assembly – сборка,
- module – модуль,
- return – возвращаемое значение,
- field (для полей, созданных компилятором),
- method (для методов, созданных компилятором).

Примеры использования атрибутов
Далее приведены несколько наиболее частых примеров использования атрибутов в коде:
- Атрибутом WebMethod в веб-сервисах помечаются методы, которые можно вызывать по протоколу SOAP.
- Описание маршалинга параметров метода при взаимодействии с машинным кодом.
- Описание свойств COM для классов, методов и интерфейсов.
- Вызов неуправляемого кода с помощью атрибута
DllImport.
- Описание названия, версии, описания или торговой марки вашей сборки.
- Описание сериализуемых членов класса.
- Описание соответствия членов класса узлам XML при XML-сериализации.
- Описание требований безопасности для методов.
- Управление оптимизацией JIT-компилятора.
- Получение информации об объекте, вызвавшем метод.

Источники:
- Джеффри Рихтер “CLR via C#”. 3-е изд. – СПб.: Питер, 2012. Глава 18.
- https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/

День пятьдесят пятый. #TipsAndTricks
Улучшите читаемость чисел, используя Разделитель Цифр в C# 7
Иногда в коде приходится использовать литеральные значения чисел. Иногда они маленькие, а иногда достаточно большие. В случае с маленькими числами проблем нет, но длинные числа иногда тяжело читать. C# 7.0 позволяет использовать разделитель ‘_’ в литералах для улучшения читаемости вашего кода. Разделитель никак не влияет на число, вы можете использовать такое число так же, как любую другую целочисленную переменную. Разделители также могут применяться в двоичных и шестнадцатеричных выражениях чисел. Начиная с версии 7.2 можно отделять также части '0b' и '0x':
var number = 123_456_789;
var binary = 0b111_1110_0011;
var binary_7_2 = 0b_111_1110_0011; // C# 7.2+
var hex = 0x7_e3;
var hex_7_2 = 0x_7e3; // C# 7.2+

День пятьдесят шестой. #ЗаметкиНаПолях
Общие атрибуты
1. Глобальные атрибуты
Применяются к сборке или модулю в целом. Например, AssemblyVersion используется для указания версии сборки:

[assembly: AssemblyVersion("1.0.0.0")]

В коде глобальные атрибуты располагаются после директив высшего уровня и перед любыми объявлениями классов, модулей или пространств имён. В проектах C# они помещаются в файл AssemblyInfo.cs.
Различают три категории атрибутов сборки:
- атрибуты идентификации сборки: обязательные атрибуты для сборки (AssemblyName, AssemblyVersion, AssemblyCulture, AssemblyFlags),
- информационные атрибуты: дополнительная информация о сборке (AssemblyProduct, AssemblyTrademark, AssemblyInformationalVersion, AssemblyCompany, AssemblyCopyright, AssemblyFileVersion, CLSCompliant)
- атрибуты манифеста сборки (AssemblyTitle, AssemblyDescription, AssemblyConfiguration, AssemblyDefaultAlias).
2. Атрибут Obsolete
Обозначает элементы программы, не рекомендуемые для дальнейшего использования. Выдаёт предупреждение компилятора или ошибку компиляции в зависимости от настройки:

[System.Obsolete("use class B")]  
class A  
{  
  public void Method() { }  
}  
class B  
{  
  [System.Obsolete("use NewMethod", true)]  
  public void OldMethod() { }  
  public void NewMethod() { }  
}  

В этом примере использование класса A приведёт к предупреждению компилятора, а использование метода OldMethod класса B к ошибке, т.к. второй параметр конструктора атрибута (error) установлен в true. Первый строковый параметр (message) используется как сообщение компилятора. Он не обязательный, но его рекомендуется задавать.
3. Условный атрибут
Условный атрибут ставит выполнение метода в зависимость от идентификатора препроцессора, определяемого в коде следующим образом:

#define CONDITION1

Чаще всего он используется с идентификатором DEBUG, для включения функций трассировки и ведения журнала для отладочных сборок (но не в релизе):

[Conditional("DEBUG")]  
static void DebugMethod() { /*…*/ }  

Атрибут определяет, вызывается или нет метод, помеченный им. Если идентификатор не определён, метод не вызывается. Условный метод должен быть определён в классе или структуре и не должен возвращать значений.
Условные атрибуты можно совмещать. Тогда метод будет исполнен, если хотя бы один из идентификаторов определён:

[Conditional("A"), Conditional("B")]  
static void DoIfAorB() { /*…*/ }

4. Атрибуты Caller Info
Используя атрибуты Caller Info, вы можете получить информацию об объекте, вызвавшем метод: имя свойства или метода, путь к исходному файлу и номер строки в файле. Атрибуты указываются для необязательных параметров метода, которые имеют значения по умолчанию:

using System.Diagnostics;
using System.Runtime.CompilerServices;

public void DoProcessing()
{
  TraceMessage("Something happened.");
}
public void TraceMessage(string message,
  [CallerMemberName] string memberName = "",
  [CallerFilePath] string sourceFilePath = "",
  [CallerLineNumber] int sourceLineNumber = 0)
{
  Trace.WriteLine("message: " + message);
  Trace.WriteLine("member name: " + memberName);
  Trace.WriteLine("source file path: " + sourceFilePath);
  Trace.WriteLine("source line number: " + sourceLineNumber);
}

// Пример вывода:
//  message: Something happened.
//  member name: DoProcessing
//  source file path: c:\Visual Studio Projects\CallerInfoCS\CallerInfoCS\Form1.cs
//  source line number: 31

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

День пятьдесят седьмой. #TipsAndTricks
8. Вспомогательные Функции
В C# 7.0 вы можете определить вспомогательную функцию внутри метода. Локальная функция может получать доступ ко всем локальным переменным, а также может использовать лямбда-выражение и даже конструкцию async-await. Но эта функция недоступна извне метода.

class Program
{
  static void Main(string[] args)
  {
    int val = 100;
    int MyLocalFunction(int value1, int value2)
    {
      return val + value1 + value2;
    }
    Console.WriteLine(MyLocalFunction(10, 10));
  }
}

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

Источник: https://dailydotnettips.com/