День восемьдесят пятый. #TipsAndTricks
Отладка в Visual Studio. Малоизвестные трюки
8. Наблюдайте за значениями переменных в рекурсивных вызовах функции
Случалось ли вам отлаживать рекурсивные функции, используя многочисленные вызовы Debug.WriteLine()? Иногда бывает сложно решить в голове, как отработает рекурсивная функция. Помочь в этом может окно Parallel Watch, в котором можно отследить изменения переменных в рекурсивном вызове.
1. Откройте окно Parallel Watch (Debug > Windows > Parallel Watch).
2. Нажмите “<Add Watch>” и введите имя нужной переменной.
3. По мере того, как вы проходите по рекурсивным вызовам, вы увидите, как они добавляются в новые строки окна.

День восемьдесят шестой. #TipsAndTricks
Отладка в Visual Studio. Малоизвестные трюки
9. Установка точки прерывания на функции без поиска её в коде
Иногда бывает нужно отладить код функции, нахождение которой в коде может вызвать трудности. Один из быстрых способов установки точки прерывания в отладчике без поиска файла и строки кода состоит в установке Точки Прерывания на Функции.
1. Нажмите Ctrl+B, либо выберите в меню Debug > New Breakpoint > Function Breakpoint.
2. Введите имя функции, на которой вы хотите установить точку прерывания. Нажмите OK.
3. Начните отладку, и заметьте, что отладчик останавливается на этой магической точке прерывания в файле кода, который вам не пришлось искать вручную.

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

yield return <expression>; // возвращает каждый элемент по одному 
yield break; // завершает итерацию

Метод-итератор используется путем применения оператора foreach или запроса LINQ. Каждая итерация цикла foreach вызывает метод-итератор. При достижении в методе-итераторе оператора yield return возвращается <expression> и сохраняется текущее расположение в коде. При следующем вызове метода-итератора выполнение возобновляется с этого места.
Небольшой пример, не имеющий особого смысла, но полезный для отладки и понимания работы yield return:

IEnumerable GetNumbers() { 
  yield return 1;
  yield return 2;
  yield return 3; 
}

Вызовем его:

foreach(var number in GetNumbers())
  Console.WriteLine(number);

Когда вы пройдёте его по шагам в отладке, вы увидите, что текущая строка выполнения прыгает между циклом foreach и выражениями yield return. То есть каждая итерация цикла вызывает метод-итератор GetNumbers до очередного выражения yield return. Значение возвращается вызывающему коду, а позиция в методе-итераторе сохраняется. Выполнение возобновляется с этой позиции при следующем вызове метода-итератора. Это продолжается, пока не будут вызваны все выражения yield return, либо не встретится yield break.

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

IEnumerable<int> GenerateWithoutYield()
{
  var i = 0;
  var list = new List<int>();
  while (i<5)
    list.Add(++i);
  return list;
}
foreach(var number in GenerateWithoutYield())
  Console.WriteLine(number)

;
Выполнение этого кода по шагам:
1. Вызывается GenerateWithoutYield.
2. Выполняется весь метод и создаётся список.
3. Цикл foreach проходит по всем значениям списка.
4. В результате числа от 1 до 5 выводятся в консоль.

Аналогичный метод с помощью yield return:

IEnumerable<int> GenerateWithYield()
{ 
  var i = 0; 
  while (i<5) 
    yield return ++i; 
} 
foreach(var number in GenerateWithYield())
  Console.WriteLine(number);

На первый взгляд этот метод тоже возвращает список из 5 чисел. Но из-за выражения yield код выполняется совершенно по-другому. Метод вообще не возвращает списка. Он создаёт итератор с обещанием вернуть 5 чисел. Несмотря на то, что результат тот же, есть некоторые нюансы выполнения:
1. Вызывается GenerateWithYield.
2. Тип возвращаемого значения этого метода IEnumerable, но это не список, а обещание вернуть последовательность чисел при запросе. Точнее создаётся итератор, позволяющий выполнить это обещание.
3. В каждой итерации цикла foreach вызывается метод-итератор. При достижении выражения yield return возвращается значение, а текущее положение запоминается. Выполнение продолжается с этого места при следующем вызове метода-итератора.
4. В результате в консоли выводятся числа от 1 до 5.

Источники:
- https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/keywords/yield
- https://www.kenneth-truyers.net/2016/05/12/yield-return-in-c/

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

День восемьдесят восьмой. #TipsAndTricks
Отладка в Visual Studio. Малоизвестные трюки
10. Изменяйте значения переменных без изменения кода
Сталкивались ли вы при отладке с тем, что значение переменной не то, которое вы ожидали? Либо вы просто хотели бы изменить его, чтобы посмотреть, как поведёт себя код? Вы можете легко это сделать при отладке, просто изменив значение переменной в памяти, используя один из следующих методов, который лучше для вас подходит (см. ниже).

1. В подсказках данных (DataTips)
Наведите курсор мыши на переменную, чтобы получить всплывающую подсказку со значением переменной. Кликните один раз на значение в подсказке, либо кликните правой кнопкой и выберите "Edit value" ("Изменить значение") из выпадающего меню. Появится курсор редактирования, и вы сможете ввести новое значение переменной.

2. В окнах Autos, Locals или Watch
Кликните дважды на значении в списке, либо кликните правой кнопкой и выберите "Edit value" ("Изменить значение") из выпадающего меню. Значение станет редактируемым, и вы сможете ввести новое значение переменной.

3. В окне Immediate
Вы можете использовать кодовый синтаксис для задания переменной нового значения. Например, вы можете ввести “x = 12;”, что изменит значение переменной x в памяти на число 12. Этот метод наиболее подходит в тех случаях, когда вам нужно провести какие-нибудь манипуляции со значением перед тем, как присвоить его переменной.

День восемьдесят девятый. #ЗаметкиНаПолях
Выражение yield return. Примеры использования
1. Кастомные итерации
Допустим, у нас есть список чисел. Мы хотим отобразить все числа, которые больше определённого числа. Обычно нам пришлось бы:
- создать временный список,
- в цикле пройти по исходному списку, сохраняя во временный список подходящие значения,
- пройти по временному списку, чтобы использовать полученные значения.
Мы можем избежать лишней работы, используя yield return:

IEnumerable<int> GetNumbersGreaterThan3(List<int> numbers) 
{
  foreach(var nr in numbers) 
  { 
    if(nr > 3) 
      yield return nr;
  }
}
foreach(var nr in GetNumbersGreaterThan3(new List<int> {1,2,3,4,5}) 
  Console.WriteLine(nr);

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

2. Итерации с сохранением состояния
Метод-итератор, содержащий yield return, сохраняет не только позицию после выдачи очередного значения, но и своё состояние:

IEnumerable<int> Totals(List<int> numbers)
{
  var total = 0;
  foreach(var number in numbers)
  {
    total += number;
    yield return total;
  }
}
foreach(var total in Totals(new List<int> {1,2,3,4,5})
  Console.WriteLine(total);

Этот код вернёт значения 1,3,6,10,15. Поскольку состояние сохраняется, переменная total будет сохранять значения между итерациями, тем самым подсчитывая промежуточную сумму чисел списка.

3. Асинхронные потоки
В C# 8 появилась возможность создавать асинхронные потоки, которые были описаны в этом посте: https://t.me/NetDeveloperDiary/88

Источники:
- https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/keywords/yield
- https://www.kenneth-truyers.net/2016/05/12/yield-return-in-c/

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

День девяностый. #TipsAndTricks
Отладка в Visual Studio. Малоизвестные трюки
11. Отмечайте потоки и выполняйте их все до выбранного места
При отладке многопоточного кода, вероятно, вам придётся делать точки останова и идти оттуда по шагам, что приведёт к тому, что программа возобновит выполнение других потоков. Иногда для поиска ошибки может быть проще остановить все потоки в одном месте, чтобы проверить состояние программы в это время. Есть простой способ сделать это, отметив потоки и вызвав команду Run Flagged Threads to Cursor (Выполнить Отмеченные Потоки до Курсора).
1. Определите интересующие вас потоки. Вы можете использовать пункт меню Show Threads in Source (Показать Потоки в Коде), окна Parallel Debugging (Параллельная Отладка) или окно Threads (Потоки).
2. Отметьте флажком интересующие вас потоки.
3. Щёлкните правой кнопкой на строке кода, в которой вы хотите исследовать состояние приложения.
4. Из контекстного меню выберите Run Flagged Threads to Cursor (Выполнить Отмеченные Потоки до Курсора).

Замечание: Когда включена опция Show Threads in Source (Показать Потоки в Коде) или видимы любые окна, относящиеся к потокам, это может серьёзно сказаться на производительности вашей сессии отладки. Рекомендуется использовать эти инструменты только когда вы действительно используете их для отладки.

День девяносто первый. #ЗаметкиНаПолях
Выражение yield return. Особенности работы
1. Множественные итерации
Побочным эффектом выражения yield return является то, что множественные вызовы приводят к множественным итерациям:

static void Main(string[] args)
{
  var invoices = GetInvoices();
  DoubleAmounts(invoices);
  Console.WriteLine(invoices.First().Amount);
}

class Invoice { public double Amount { get; set; } }
static IEnumerable<Invoice> GetInvoices()
{
  for (var i = 1; i < 11; i++)
    yield return new Invoice { Amount = i * 10 };
}
static void DoubleAmounts(IEnumerable<Invoice> invoices)
{
  foreach (var invoice in invoices)
    invoice.Amount = invoice.Amount * 2;
}

Попробуйте догадаться, что будет выведено в консоль? Несмотря на то, что интуиция подсказывает результат 20, выведено будет 10:
1. Когда выполняется строка var invoices = GetInvoices(); мы не получаем список счетов (Invoice), мы получаем итератор, создающий объекты Invoice.
2. Этот итератор передаётся в метод DoubleAmounts.
3. Внутри метода DoubleAmounts итератор используется для создания объектов Invoice и удвоения суммы счёта (свойство Amount) каждого объекта.
4. Однако все объекты, созданные в методе DoubleAmounts, выбрасываются, поскольку на них нет ссылок из внешнего кода.
5. Когда мы возвращаемся во внешний код, у нас остаётся только ссылка на итератор. Вызывая метод First, мы снова просим создать объект Invoice. Это новый объект, поэтому в результате его свойство Amount будет иметь значение 10.
Поскольку это неочевидное поведение, инструменты вроде Resharper предупреждают вас о множественных итерациях.
2. Отложенное выполнение
Все примеры использования yield return имеют общее свойство. Код выполняется только тогда, когда это необходимо. Механизм паузы/возобновления в методе-итераторе делает это возможным. Используя отложенное выполнение, мы можем делать методы проще, иногда быстрее, а иногда и в принципе делать возможным то, что было невозможно ранее. Например, можно сделать бесконечный генератор чисел и выбирать из него только нужное количество. Весь модуль LINQ в C# построен вокруг отложенного исполнения. Вот как оно повышает эффективность кода:

var dollarPrices = FetchProducts().Take(10)
  .Select(p => p.CalculatePrice())
  .OrderBy(price => price)
  .Take(5)
  .Select(price => ConvertTo$(price));

Допустим, у нас 1000 продуктов. Без отложенного выполнения, методу бы пришлось:
1. Выбрать все 1000 продуктов
2. Посчитать цену всех 1000 продуктов
3. Выстроить все продукты по возрастанию цены
4. Перевести все цены в доллары
5. Выбрать 5 продуктов с самой высокой ценой
Используя отложенное выполнение, код:
1. Выбирает 10 продуктов
2. Вычисляет цену 10 продуктов
3. Выстраивает из по возрастанию цены
4. Отбирает первые 5 и переводит их цены в доллары
Несмотря на то, что это выдуманный пример, он чётко показывает, как отложенное выполнение может сильно повысить эффективность. Хотя, заметьте, что пример с отложенным выполнением может делать не то, что вы хотите. В примере выше из всех продуктов отбираются не 10 с наиболее высокой ценой, а 10 первых попавшихся. Поэтому нужно быть внимательным в порядке вызова методов LINQ.

Источники:
- https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/keywords/yield
- https://www.kenneth-truyers.net/2016/05/12/yield-return-in-c/

День девяносто второй. #TipsAndTricks
Отладка в Visual Studio. Малоизвестные трюки
12. Переключение между потоками для просмотра контекста
Окно Parallel Watch отлично подходит для наблюдения за переменными в разных потоках. Но что если вам нужно посмотреть подробное состояние приложения в одном из потоков? Желтая стрелка показывает текущую строку в текущем потоке и устанавливает контекст во всём отладчике. Окна Watch, Data-tips и Call Stack показывают состояние в этом контексте. Отладчик может легко переключиться на другой контекст при выборе пункта меню Switch to Thread… (Переключиться на Поток…).
1. Выберите поток, который хотите исследовать. Вы можете сделать это, используя команду Show Threads in Source (Показать Потоки в Коде), окна Parallel Debugging (Параллельная Отладка) или Threads (Потоки).
2. Нажмите правой кнопкой, выберите Switch to Thread… и ваш поток.
3. Заметьте, что желтая стрелка переместилась на положение в коде выбранного потока, а остальные окна теперь содержат контекст этого потока.

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

День девяносто третий. #TipsAndTricks
Использование ключевого слова explicit для явного приведения типов бизнес-логики
Ключевое слово explicit позволяет вам создать оператор явного приведения типа для вашего класса, что может быть полезно при реализации некоторых бизнес-правил. Этот оператор вызывается при выполнении приведения типов. В примере ниже ключевое слово explicit используется для обозначения оператора явного приведения в типе MyEntity, который будет вызываться при попытке приведения типа ExternalEntity к типу MyEntity:

class Program 
{
  static void Main(string[] args)
  {
    ExternalEntity entity = new ExternalEntity()
    {
      Id = 1001,
      FirstName = "Dave",
      LastName = "Johnson"
    };

    MyEntity convertedEntity = (MyEntity)entity;
  }
  
  class MyEntity
  {
    public int Id { get; set; }
    public string FullName { get; set; }
    public static explicit operator MyEntity(ExternalEntity externalEntity)
    {
      return new MyEntity() {      
        Id = externalEntity.Id,
        FullName = externalEntity.FirstName + " " + externalEntity.LastName
      }
    }
  }
  
  class ExternalEntity
  {
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
  }
}

Источник: https://www.freelancer.com/community/articles/top-16-c-programming-tips-tricks

День девяносто четвёртый. #ЧтоНовенького
Новинки VS2019 для Повышения Продуктивности
1. Языковая Поддержка Regex
Любое регулярное выражение в ваших файлах C# или Visual Basic теперь имеет подсветку синтаксиса, диагностируется компилятором и включает подчёркивание ошибок и всплывающие подсказки. Эта поддержка парсинга регулярных выражений может распознавать строки, передаваемые в конструктор регулярного выражения, либо строки, которым непосредственно предшествует комментарий, содержащий строку language=regex. Функционал языка на данный момент включает классификацию выражений, сопоставление скобок, подсветку ссылок и диагностику компилятором.

Источник: https://devblogs.microsoft.com/dotnet/visual-studio-2019-net-productivity/

День девяносто пятый. #ЧтоНовенького
Новинки VS2019 для Повышения Продуктивности
2. Инструменты Правки Кода и Рефакторинга
В Visual Studio 2019 добавлены наиболее востребованные функции правки кода и рефакторинга. Многие из них были разработаны сообществом программистов. Подсказки по рефакторингу доступны при нажатии Ctrl+. или Alt+Enter. Среди них:
1. Преобразование цикла foreach в LINQ (см. ниже)
2. Добавление нужных директив using при копировании/вставке.
3. Преобразование анонимного типа в класс.
4. Преобразование локальной функции в метод.
5. Преобразование кортежа в именованную структуру.
6. Анализ "мёртвого кода" на неиспользуемые непубличные члены класса с возможностью их удаления.
7. Генерация метода деконструкции.
8. Добавление ключевого слова await там, где оно подразумевается, но не вызывает предупреждения компилятора.

Источник: https://devblogs.microsoft.com/dotnet/visual-studio-2019-net-productivity/

К уже существующим методам рефакторинга циклов, включающим преобразование LINQ в foreach, цикла for в foreach и наоборот, добавлена возможность преобразования цикла foreach в запрос или метод LINQ.

День девяносто шестой. #ЧтоНовенького
Новинки VS2019 для Повышения Продуктивности
3. Чистая загрузка решения
Когда решение закрывается, его состояние сохраняется, чтобы, когда в следующий раз вы его откроете, Visual Studio смогла восстановить все открытые файлы, свёрнутые/развёрнутые папки проектов в Solution Explorer (Проводник Решения) и т.п. Это отлично, но иногда лучше открывать решение в чистом (пустом) состоянии: без открытых файлов и со всеми свёрнутыми папками в Проводнике Решения.
Эта функциональность добавлена в Visual Studio 2019 и может быть включена в двух отдельных флажках. Откройте из меню опций Projects and Solutions > General (Проекты и Решения > Общие).
Снимите флажок с пунктов Reopen documents on solution load (Открывать документы при загрузке решения) и Restore Solution Explorer project hierarchy (Восстанавливать иерархию проекта в Проводнике Решения). Кроме прочего, решения в такой конфигурации будут загружаться быстрее, потому что пропускается шаг восстановления состояния.

День девяносто седьмой. #ЧтоНовенького
Новинки VS2019 для Повышения Продуктивности
4. Git pull по ссылке
Если вам нужно постоянно работать с git и обновлять код из репозитория, вы скорее всего сталкивались с ситуацией, когда вы изменяете код, забыв обновить локальную копию. Это ведёт к возникновению конфликтов слияния и другим проблемам. Единственным способом сделать git pull в прошлом было использование Team Explorer, командной строки или стороннего инструмента.
Теперь команде pull в Team Explorer можно назначить горячие клавиши. Зайдите в умный поиск (Ctrl+Q) и введите “keyboard”, чтоб найти страницу опций Environment > Keyboard. Там найдите в списке команду Team.Git.Pull. Затем вы сможете назначить любые горячие клавиши этой команде и нажать кнопку OK. Например, Ctrl+Shift+P.
Чтобы автоматически выполнять команду git pull при загрузке решения, попробуйте бесплатное расширение Git Pull https://marketplace.visualstudio.com/items?itemName=MadsKristensen.GitPull

День девяносто восьмой. #ЧтоНовенького
Новинки VS2019 для Повышения Продуктивности
5. Очистка Кода для C#
Поддержание кода хорошо отформатированным и с соблюдением стилей – это то, чем славятся очень немногие. Новый инструмент Code Cleanup (Очистка Кода) – отличный помощник в этом.
Чтобы выполнить очистку кода, выберите меню Code Cleanup на нижней границе окна редактирования и нажмите Configure Code Cleanup (Настроить Очистку Кода).
В этом диалоге выберите все нужные "фиксеры" по одному из списка доступных внизу и нажмите стрелку вверх, чтобы перенести их в список используемых вверху. Нажмите OK.
Теперь все фиксеры будут применяться каждый раз, когда вы используете Code Cleanup. Нажмите Ctrl+K, Ctrl+E, чтобы запустить очистку. В результате будет хорошо отформатированный документ с набором применённых стилей, таких как пропущенные скобки или модификаторы.