.NET Разработчик
6.7K subscribers
470 photos
4 videos
14 files
2.33K links
Дневник сертифицированного .NET разработчика. Заметки, советы, новости из мира .NET и C#.

Для связи: @SBenzenko

Поддержать канал:
- https://boosty.to/netdeveloperdiary
- https://patreon.com/user?u=52551826
- https://pay.cloudtips.ru/p/70df3b3b
Download Telegram
День 2646. #ЗаметкиНаПолях
Тестовая Пирамида — Ложь (и Что Делать Вместо Этого). Окончание

Начало

Что делать вместо тестовой пирамиды
Вот структура тестов для типичного сервиса .NET или модульного монолита.

Уровень 1: Тонкая база модульных тестов (15-25% тестов)
Вся логика домена. Никаких контейнеров или моков. Микросекунды на тест. Для этого и существуют модульные тесты. Если модульному тесту нужен мок, то он будет на уровне интеграции.
[Fact]
public void Confirm_WhenPending_TransitionsToConfirmed()
{
var order = Order.Create(
CustomerId.New(), Money.Usd(100));

order.Confirm();

order.Status.Should()
.Be(OrderStatus.Confirmed);

order.DomainEvents.Should()
.ContainSingle(e => e is OrderConfirmedEvent);
}


Уровень 2: Толстый средний слой интеграционных тестов (60-70%)
Все обработчики команд и запросов, все конечные точки HTTP, все потребители сообщений тестируются на реальной инфраструктуре внутри тестовых контейнеров. В модульном монолите именно здесь проверяется корректность взаимодействия модулей друг с другом через их публичные API.
public class DeleteAccountTests(
IntegrationTestWebAppFactory factory)
: BaseIntegrationTest(factory)
{
[Fact]
public async Task DeleteAccount_MarksAccountDeleted()
{
var acc = await CreateAccountAsync();

var resp = await HttpClient
.DeleteAsync($"/accounts/{acc.Id}");

resp.StatusCode.Should().Be(HttpStatusCode.NoContent);

var stored = await DbContext.Accounts
.IgnoreQueryFilters()
.SingleAsync(a => a.Id == acc.Id);

stored.IsDeleted.Should().BeTrue();
}
}

Эти тесты проверяют слой HTTP, маршрутизацию, привязку модели, авторизацию, обработчики, контексты, EF Core и PostgreSQL. Они доказывают то, что вас действительно интересует: когда я вызываю эту конечную точку, строка в базе изменяется. И это происходит без необходимости кому-либо помнить о вызове SaveChangesAsync и проверке, вызывается ли он.

Уровень 3: Небольшое количество сквозных тестов (<10%)
Только те потоки, где скрытый сбой может представлять коммерческую проблему или проблему соответствия требованиям. Регистрация, оплата, возврат средств, сброс пароля, двухфакторная аутентификация. Они медленные и иногда нестабильные, но они выявляют тот единственный режим отказа, который все остальные тесты пропускают: система в целом продолжает работать.

Уровень 0: Архитектурные и контрактные тесты
Часто забываются, но они являются частью набора тестов. Архитектурные тесты обеспечивают соблюдение разделения на слои и границ модулей. Контрактные тесты проверяют, что схемы сообщений и формат API не меняются. Они выполняются за миллисекунды и выявляют ошибки типа «через шесть месяцев кто-то сломает это, не заметив».

Полученная форма больше напоминает ромб, чем пирамиду. Толстая середина — это намеренное решение. Именно отсюда и берётся уверенность в тестах.

Обычные возражения
«Интеграционные тесты медленные». Мой типичный набор интеграционных тестов выполняется за 2-4 минуты в CI с повторным использованием Testcontainers и распараллеливанием тестовых классов. Медленнее, чем модульные тесты? Да. Но быстрее, чем обнаружение ошибки в продакшене.

«Моки хороши, если вы дисциплинированы». Возможно. Но в каждой крупной кодовой базе, которую я проверял и которая сильно полагалась на моки, была одна и та же патология: тесты проходят после рефакторинга, даже если рефакторинг сломал продакшен. Это не проблема дисциплины. Это неправильное использование инструмента.

Итого
Пирамида тестирования была хорошим советом для инфраструктуры 2009 года, но является плохим советом для инфраструктуры 2026 года. Testcontainers и Aspire изменили экономику, и самый быстрый цикл обратной связи, который по-прежнему сообщает правду, теперь — это интеграционный тест с реальными зависимостями. Модульные тесты по-прежнему должны быть сосредоточены на чистой логике предметной области. Всё, что переходит через границы модулей, должно быть на уровне интеграции.

Источник: https://www.milanjovanovic.tech/blog/the-test-pyramid-is-a-lie-and-what-i-do-instead
1👍6
День 2647. #ProjectManagement
Как Проваливаются Разработчики ПО. Начало
«Разработчики ПО терпят неудачу двумя способами: они либо делают продукт не так, либо делают не тот продукт».

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

1. Неправильная разработка продукта
Техническое исполнение неверное. Требования могли быть поняты правильно, но реализация была ошибочной. Например:
- Ошибки, вызывающие некорректное поведение;
- Низкая производительность, делающая ПО непригодным;
- Уязвимости безопасности, подвергающие пользователей риску;
- Хрупкая архитектура, которая затрудняет обслуживание или расширение системы;
- Код настолько сложный или запутанный, что никто не может безопасно его изменить.
Про эти неудачи мы чаще всего говорим. Проверки кода, автоматизированное тестирование, статический анализ и конвейеры CI/CD, существуют в первую очередь для того, чтобы выявлять и предотвращать подобные неудачи.

2. Создание неправильного продукта
Техническое исполнение может быть безупречным, но ПО не решает нужную проблему. Продукт компилируется, запускается и может работать без проблем. Но есть признаки того, что вы создали не то, что нужно:
- Решает проблему, с которой на самом деле никто не сталкивается;
- Решает проблему, которая никому на самом деле не важна;
- Решает вчерашнюю проблему, а не сегодняшнюю;
- Предоставляет функции, которые запрашивали пользователи, но не то, что им действительно было нужно;
- Делает неверные предположения о том, как должно быть реализовано решение.
Это более тонкий и часто более дорогостоящий случай. Прекрасно разработанное, безошибочное и производительное приложение может не приносить никакой пользы, потому что оно изначально решает не ту проблему. Все усилия потрачены впустую.

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

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

Более опасная ошибка — успешный выпуск чего-то, что не нужно. А иногда и нежелательно. Это может создать у команды разработчиков ложное чувство успеха, которое затем приводит к ещё большему разочарованию, когда им приходится откатывать изменения или вносить серьёзные обновления. Почти всегда это ошибка в коммуникации, а не в навыках программистов, и усилия, необходимые для её исправления, обычно более масштабны, постоянны (нельзя просто добавить ещё один этап сборки) и, вероятно, затронут несколько команд внутри организации. И Scrum, и XP предполагают наличие в команде разработчиков эксперта в предметной области, представляющего заказчика, но организации редко нанимают такого специалиста. Чаще это делается кем-то не связанным с командой разработчиков, кому отводится дополнительная роль «владельца продукта» или «эксперта в предметной области», чтобы разработчики могли обращаться к нему с вопросами и, возможно, периодически встречаться, и его вряд ли можно считать полноценным членом команды.

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

Источник:
https://ardalis.com/how-software-developers-fail/
👍6👎1
День 2648. #ProjectManagement
Как Проваливаются Разработчики ПО. Продолжение

Начало

Эпоха агентской разработки
ИИ-агенты меняют подход к разработке. Они позволяют писать, тестировать, рефакторить и развёртывать код с минимальным участием человека. Перспективы огромны: значительное повышение продуктивности разработчиков, снижение трудозатрат, ускорение итераций. Больше кода быстрее. Но ИИ-агенты не меняют существующие виды проблем, они их усиливают.

Агенты хорошо умеют создавать вещи неправильно
ИИ-агенты могут быстро генерировать большие объёмы неверного кода:
- Вносить скрытые уязвимости безопасности, которые трудно обнаружить при проверке кода;
- Писать код, который выглядит корректно, но имеет ошибки в крайних случаях;
- Исполнять заявленные требования, игнорируя подразумеваемые ограничения;
- Уверенно выдавать некорректные результаты («галлюцинации»).
Преимущество ИИ-агентов в скорости означает, что если контроль качества отсутствует, вы можете накопить гораздо больше технического долга и гораздо больше ошибок за то же время. Как никогда необходимы тесты, проверка кода (человеческая и автоматизированная) и надёжные конвейеры CI/CD. Быстрая поставка — это преимущество только в том случае, если то, что вы выпускаете, работает.

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

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

Поэтому навыки, помогающие командам создавать правильный продукт, важны как никогда:
1. Чёткие требования и пользовательские истории. Большинство агентов созданы для того, чтобы продолжать работу, пока не почувствуют, что решили проблему. Если у них нет всех деталей, они будут гадать. Так же, как часто делают люди, но без человеческого суждения и с гораздо большей скоростью.

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

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

4. Продуктовое мышление. Способность задавать вопрос «Стоит ли вообще это делать?» — это (сегодня) уникальный человеческий навык, и его ценность постоянно растёт.

Окончание следует…

Источник:
https://ardalis.com/how-software-developers-fail/
👍3👎1
День 2649. #ProjectManagement
Как Проваливаются Разработчики ПО. Окончание

Начало
Продолжение

Эффект накопления
Стоимость создания неправильного продукта людьми ограничена скоростью человека. Команда за спринт может создать 10-15 функций. С ИИ-агентами та же команда теперь может создавать 10-15 функций в день. Если эти функции неверны, потери — и количество необходимых исправлений — кратно увеличиваются. Хуже того, большая кодовая база, полная неправильных функций, создает накопительную сложность: будущим агентам (и людям) придётся обходить все ошибки, которые были допущены. Агенты отлично следуют существующим шаблонам: большая кодовая база, полная неправильных функций, будет использована в качестве модели для следующей функции. Преимущество мощности ИИ-агентов делает их опасными, когда они делают не то.

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

1. Вкладывайте значительные усилия в требования и спецификации. Чем яснее и точнее входные данные для ИИ-агентов, тем лучше результаты. Расплывчатые требования, которые разработчик-человек мог бы разумно интерпретировать, будут реализованы агентом буквально — или, что ещё хуже, изобретательно.

2. Автоматизируйте контрольные точки качества. Код, сгенерированный ИИ, нуждается в автоматизированных тестах, проверке синтаксиса, сканировании безопасности и других проверках качества. Эти контрольные точки становятся основной защитой от ошибок при масштабировании. Их также гораздо проще создать с помощью ИИ-агентов, поэтому важно настроить их с самого начала.

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

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

5. Измеряйте результаты, а не только объём. В случае с ИИ-агентами возникает соблазн измерить объём выпущенного кода. Но важно то, получают ли пользователи выгоду. Отслеживайте использование, удовлетворённость пользователей и бизнес-результаты наряду с показателями скорости.

6. Оптимизируйте последующие процессы. Сегодня ИИ-агенты могут создавать код в десять раз быстрее людей. Но создание кода не было узким местом раньше, и уж точно не является им сейчас. Ускорение не являющихся узкими местами процессов в системе приводит лишь к увеличению потерь и замедлению общей доставки. Прежде чем натравить ИИ-агентов на весь ваш бэклог, убедитесь, что вы создали контрольные точки качества, автоматические проверки развёртывания, тестовые среды, где новые функции могут быть оценены и утверждены людьми, и т.д.

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

Быстрое движение имеет значение только в том случае, если вы движетесь в правильном направлении. Как гласит классическая цитата: «Мы заблудились, зато мы всех опережаем!»

Источник: https://ardalis.com/how-software-developers-fail/
👍7👎1
День 2650. #ВопросыНаСобеседовании
Марк Прайс предложил свой набор из 60 вопросов (как технических, так и на софт-скилы), которые могут задать на собеседовании.

32. Синтаксис Razor
«Расскажите, что такое Razor и как он используется в приложениях ASP.NET Core? Приведите пример».

Хороший ответ
Razor — это синтаксис разметки, который позволяет встраивать код C# в HTML-документы для динамической генерации HTML-контента на сервере перед его отправкой клиенту. Он используется в основном в представлениях ASP.NET Core MVC, Razor Pages и веб-приложениях Blazor для создания динамических веб-страниц.

Блоки кода в Razor начинаются с символа @, который помогает компилятору отличать код C# от HTML. Это позволяет беспрепятственно интегрировать серверную логику в структурированный HTML-файл, расширяя возможности рендеринга веб-страниц на основе динамических данных.

В качестве примера синтаксиса Razor в представлении ASP.NET Core MVC рассмотрим простую модель, представляющую продукт:
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
}

В следующем представлении показано, как отобразить список продуктов:
@model IEnumerable<Product>
<h2>Список Продуктов</h2>
<table>
<thead>
<tr>
<th>Название</th>
<th>Цена</th>
</tr>
</thead>
<tbody>
@foreach (var p in Model)
{
<tr>
<td>@p.Name</td>
@* Денежный формат *@
<td>@p.Price.ToString("C")</td>
</tr>
}
</tbody>
</table>


В этом примере синтаксис Razor используется для итерации по коллекции объектов Product, переданных в представление из контроллера. Он динамически генерирует строки таблицы (<tr>) для каждого продукта с его названием и ценой. Символ @ используется для вставки кода C# в HTML для итерации по списку и отображения данных.

Преимущества использования Razor включают:
- Повышение производительности: Razor снижает сложность написания и поддержки динамических веб-страниц, позволяя разработчикам писать код C# непосредственно в представлении.
- Строгая типизация: Используя C# в представлении, Razor поддерживает IntelliSense и проверку кода во время компиляции, уменьшая количество ошибок во время выполнения.
- Чёткое разделение: Razor помогает поддерживать чёткое разделение задач между логикой пользовательского интерфейса и логикой бэкэнда, придерживаясь паттерна MVC.

Часто встречающийся неверный ответ
«Синтаксис Razor — это просто использование символа @ для написания любого кода C# непосредственно в HTML. Можно выполнять любую бизнес-логику в представлении, чтобы манипулировать данными так, как вам нужно».

Почему это неправильно
- Неправильное использование Razor для бизнес-логики: Этот ответ предполагает ненадлежащее использование представлений Razor для выполнения бизнес-логики, что нарушает принцип разделения ответственности в MVC. Представления Razor предназначены для обработки логики представления, а не бизнес-логики.

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

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

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

Источник: https://github.com/markjprice/tools-skills-net8/blob/main/docs/interview-qa/readme.md
👎7👍2
День 2651. #ЧтоНовенького
VSTest удаляет зависимость от Newtonsoft.Json

Начиная с .NET 11 Preview 4 и Visual Studio 18.8, VSTest, платформа, на которой работают dotnet test и Test Explorer, больше не будет зависеть от Newtonsoft.Json. Теперь будет использоваться System.Text.Json в .NET и JSONite в .NET Framework. Большинству проектов никаких действий не требуется. Небольшое количество проектов может столкнуться с ошибкой сборки или тестирования и решить её добавлением одной строки PackageReference.

Зачем?
VSTest годами поставлялся с Newtonsoft.Json в составе .NET SDK и Visual Studio. Все версии Newtonsoft.Json ниже 13.0.0 теперь помечены как уязвимые на NuGet.org, и наличие этой зависимости делает тестовую платформу уязвимой в компоненте, который ей больше не нужен. Удаление является частью более масштабной работы по удалению Newtonsoft.Json из .NET SDK.

Что не меняется?
- Формат передачи VSTest. Сообщения сериализуются одинаково независимо от того, используется ли Newtonsoft.Json, System.Text.Json или JSONite.
- Старые тестовые хосты остаются совместимыми с обновлённой платформой, и наоборот.
- Производительность сериализации остается прежней или улучшается.

Кого это НЕ затронет?
Большинство тестовых проектов:
- Проекты, которые не используют Newtonsoft.Json.
- Проекты, которые ссылаются на Newtonsoft.Json в виде обычной ссылки PackageReference.
- Проекты xUnit и NUnit, работающие на .NET или использующие AppDomains. Для них уже требовалась явная ссылка.

Кого это затронет и как это исправить
Каждая из перечисленных ниже ошибок не является скрытой, сообщается в ходе выполнения теста и передаётся в TRX и представления тестов Azure DevOps / GitHub.

1. Ошибка сборки: отсутствует ссылка на Newtonsoft.Json
Если тестовый проект использует типы Newtonsoft.Json (например, JObject, JsonConvert) без ссылки на этот пакет, ранее он компилировался только потому, что Newtonsoft.Json просачивался через VSTest. После обновления это будет не так.
Исправление: добавьте пакет.
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />


2. Ошибка выполнения: FileNotFoundException для Newtonsoft.Json
Проекты, которые ссылаются на Newtonsoft.Json, но не содержат ресурс времени выполнения — например:
<PackageReference Include="Newtonsoft.Json" Version="13.0.3">
<ExcludeAssets>runtime</ExcludeAssets>
</PackageReference>

Предполагалось, что копия библиотеки из VSTest будет присутствовать во время тестирования. После этого обновления запуск теста завершится с ошибкой:
System.IO.FileNotFoundException: Could not load file or assembly 'Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed'.

Исправление: уберите <ExcludeAssets>runtime</ExcludeAssets>, либо установите Newtonsoft.Json без исключения ресурсов времени выполнения.

3. Ошибка загрузки расширения в тестовом адаптере или сборщике данных
Адаптеры и сборщики данных, которые использовали Newtonsoft.Json, не указав его в качестве зависимости, завершатся с ошибкой во время загрузки с сообщением, подобным следующему:
Data collector 'SampleDataCollector' threw an exception during type loading, construction, or initialization: System.IO.FileNotFoundException: Could not load file or assembly 'Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed'.

В сообщении будет указано имя расширения, которое необходимо обновить, однако на данный момент о таких проблемах не сообщалось. Авторам расширений следует добавить Newtonsoft.Json в свой пакет (или отказаться от него); пользователи могут добавить Newtonsoft.Json в тестовый проект или отключить затронутое расширение до его обновления.

Изменение публичного API
VSTest предоставлял доступ к Newtonsoft.Json.Linq.JToken в одном месте своего API связи. Этот тип удаляется из публичного доступа. Он имел смысл только для кода, участвующего в протоколе VSTest, и вряд ли будет использоваться реальными пользователями, но авторам расширений следует об этом знать.

Источник: https://devblogs.microsoft.com/dotnet/vs-test-is-removing-its-newtonsoft-json-dependency/
👍3
День 2652. #МоиИнструменты #PG
Инструменты Оптимизации Запросов в PostgreSQL. Часть 8

8. QueryPie (совместная работа с SQL + оптимизация)
Что даёт: Совместная работа команды над оптимизацией запросов со встроенным анализом производительности.
Тип: Коммерческий (доступен бесплатный уровень)
Базы данных: Postgres, MySQL, Redshift, BigQuery, Snowflake

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

Как работает
Пишете запрос в IDE QueryPie -> Автоматически запускается EXPLAIN ANALYZE -> Отображаются показатели производительности -> Делитесь запросом с командой по ссылке -> Члены команды предлагают варианты оптимизации -> A/B-сравнение версий запроса -> Лучшая версия продвигается в прод.

Пример рабочего процесса
1. Аналитик данных пишет запрос (QueryPie IDE)
SELECT 
c.customer_name,
SUM(o.total) as revenue
FROM customers c
LEFT JOIN orders o ON c.id = o.customer_id
WHERE c.country = 'US'
GROUP BY c.customer_name
ORDER BY revenue DESC
LIMIT 100;

2. Вывод QueryPie:
Execution time: 23.4s
Rows scanned: 5.2M
Cost: $0.45 (Вымышленная валюта)
Warning: LEFT JOIN inefficient (NULL handling overhead)

3. Разработчик нажимает "Предложить оптимизацию". ИИ QueryPie предлагает:
SELECT 
c.customer_name,
SUM(o.total) as revenue
FROM customers c
INNER JOIN orders o ON c.id = o.customer_id -- Добавить INNER
WHERE c.country = 'US'
AND o.total IS NOT NULL -- Добавить фильтр
GROUP BY c.customer_name
ORDER BY revenue DESC
LIMIT 100;

4. Новые метрики:
Execution time: 1.2s (19x faster)
Rows scanned: 234K (22x less)
Cost: $0.02 (22x cheaper)

5. Показывается сравнение результатов.
6. При нажатии кнопки «Принять оптимизацию» исходный запрос помечается как устаревший, команда уведомляется об улучшении.

Когда использовать
- Несколько человек пишут SQL-запросы;
- Требуется совместная оптимизация;
- Необходимо версионирование запросов;
- Предпочитаете веб-IDE локальным инструментам.

Когда отказаться
- Разработчик-одиночка (функции совместной работы не используются);
- Довольны текущей IDE (pgAdmin, DBeaver и т. д.);
- Очень ограниченный бюджет ($15-50 на пользователя в месяц).

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

С осторожностью
QueryPie хранит результаты запросов. Соображения конфиденциальности:
- Запросы выполняются через прокси QueryPie;
- Результаты кэшируются для обмена;
- Может содержать конфиденциальные данные.

Конфигурация:
- Установить политику хранения данных (по умолчанию 7 дней);
- Исключить столбцы с персональными данными из кэширования;
- Использовать локальное развёртывание для конфиденциальных данных;
- Перед развёртыванием командой проверить политики безопасности.

Источник:
https://medium.com/@reliabledataengineering/15-sql-optimization-tools-that-make-queries-10x-faster-8629ac451d97
👍3
День 2653. #Оффтоп
История Архитектур Приложений в .NET. Начало

Ранние годы
Классический ASP / «Спагетти-код» (конец 1990-х). До появления .NET веб-приложения Microsoft создавались с помощью классического ASP — скриптового языка VBScript, смешанного с HTML. Реальной архитектуры не было; бизнес-логика, доступ к данным и представления были переплетены между собой. От этого отказались, потому что это было неподдерживаемо, нетестируемо и немасштабируемо.

Web Forms (2002–~2012). ASP.NET Web Forms был первым крупным веб-фреймворком .NET от Microsoft. Он пытался сделать веб-разработку похожей на разработку настольных приложений, абстрагируя HTTP с помощью модели, основанной на состоянии и событиях (ViewState, postbacks, серверные элементы управления). Его заменили, потому что абстракция сильно «протекала». Она создавала раздутый HTML, делала модульное тестирование практически невозможным, противоречила тому, как на самом деле работает веб, и давала разработчикам очень мало контроля над отображаемым результатом. К тому времени, когда появились jQuery, а затем и фронтенд-фреймворки, Web Forms казался архаичным.

Основополагающие шаблоны (по-прежнему актуальны, но эволюционировали)
Многоуровневая/трёхуровневая архитектура. Классический многоуровневый подход: представление → бизнес-логика → доступ к данным. Это был основной принцип работы корпоративного .NET на протяжении многих лет. Теоретически каждый уровень мог быть развёрнут независимо. Он не устарел сам по себе, но был усовершенствован. Проблема заключалась в том, что на практике команды часто получали «анемичный» бизнес-слой, который просто передавал данные, и тесную связь между слоями через общие DTO или модели Entity Framework, просачивающиеся вверх.

MVC (Модель-Представление-Контроллер). ASP.NET MVC был запущен примерно в 2009 году как «противоядие» от Web Forms. Он использовал HTTP, предоставлял разработчикам контроль над HTML, позволял проводить модульное тестирование и правильно соблюдал принцип разделения ответственности. MVC по-прежнему широко используется в ASP.NET Core, хотя Razor Pages и Minimal API стали использоваться в более простых сценариях. MVC остается предпочтительным вариантом для сложных веб-приложений с множеством контроллеров и представлений.

MVVM (Модель-Представление-Модель Представления). Этот шаблон стал доминирующим в настольных приложениях WPF и Silverlight, а позже и в Xamarin. Модель Представления (ViewModel) предоставляет данные и команды, к которым представление привязывается декларативно. MVVM по-прежнему является основным шаблоном для .NET MAUI (преемника Xamarin.Forms) и WPF. Silverlight мёртв, но концепция MVVM процветает.

Сервисно-ориентированные шаблоны
WCF (Windows Communication Foundation). Представлял собой унифицированную платформу Microsoft для создания сервисно-ориентированных приложений — SOAP, REST, именованные каналы, TCP, очереди сообщений — всё в рамках одной модели программирования. Был невероятно мощным и таким же сложным. Конфигурация была печально известна своей сложностью (бесконечные XML-файлы). WCF был вытеснен, потому что отрасль перешла к легковесным REST/HTTP API, и сложность WCF не была оправдана для большинства вариантов использования. ASP.NET Web API, а позже и ASP.NET Core, заняли его место. Существует поддерживаемый сообществом проект CoreWCF для сценариев миграции, но новые проекты почти никогда не выбирают WCF.

Web API / REST ASP.NET Web API (2012), а затем и ASP.NET Core сделали создание HTTP API простым. Теперь это стандарт для взаимодействия сервисов в .NET. Минимальные API в .NET 6+ ещё больше упростили его для небольших сервисов.

gRPC. Для взаимодействия между сервисами, где важна производительность, gRPC (поддерживается нативно в ASP.NET Core) предлагает бинарную сериализацию через Protocol Buffers, потоковую передачу HTTP/2 и строгие контракты. Это современная замена WCF в сценариях взаимодействия между сервисами, где не требуется совместимость с браузерами.

Окончание следует…

Источник:
https://todayamerican.medium.com/net-c-application-architecture-over-time-7218f0470a02
👍9👎1
День 2654. #Оффтоп
История Архитектур Приложений в .NET. Окончание

Начало

Современные архитектурные стили
Чистая/Луковая/Гексагональная архитектура. Это вариации одной идеи: инвертирование направления зависимостей, чтобы доменная/бизнес-логика находилась в центре, без зависимостей от инфраструктуры. Инфраструктура (БД, файловая система, внешние API) зависит от домена через абстракции (интерфейсы), а не наоборот. Это вытеснило наивный многоуровневый подход, поскольку делает бизнес-логику действительно тестируемой и заменяемой. Чистая архитектура (популяризированная Робертом Мартином и в .NET шаблоном Джейсона Тейлора) — вероятно, самая распространённая «серьёзная» архитектура для приложений .NET сегодня.

CQRS (Разделение Ответственности Команд и Запросов). Разделяет операции чтения (запросы) и записи (команды). Часто используется в сочетании с MediatR в .NET. Добавляет сложности, поэтому лучше всего подходит для областей, где шаблоны чтения и записи значительно различаются.

Источники событий (Event Sourcing). Вместо хранения текущего состояния вы храните последовательность событий, которые привели к текущему состоянию. Часто используется в сочетании с CQRS. Мощный инструмент для журналов аудита и сложных доменов, но значительно усложняет систему. Это нишевый шаблон — ценный, когда он необходим, избыточный, когда нет.

Микросервисы. Разделение приложения на независимо развёртываемые сервисы, каждый из которых владеет собственными данными. В .NET имеет сильную поддержку благодаря ASP.NET Core, Docker, Kubernetes и .NET Aspire. Микросервисы вытеснили монолиты для больших команд и сложных областей, но наблюдается заметное движение против них, признающее, что микросервисы вносят сложность распределённых систем (сбои сети, конечная согласованность, операционные накладные расходы), с которой многие команды не готовы справиться.

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

Шаблоны для настольных/клиентских приложений
Windows Forms (WinForms) — всё ещё поддерживается, все ещё используется, но в значительной степени считается устаревшим фреймворком для новой разработки. Имеет событийно-ориентированный, тесно связанный код пользовательского интерфейса.

WPF. Более современный фреймворк для настольных приложений с MVVM, привязкой данных и XAML. Всё ещё активно поддерживается и используется для сложных настольных приложений.

Xamarin → .NET MAUI — кроссплатформенное мобильное/настольное приложение. Xamarin снят с поддержки; MAUI — его преемник, использующий шаблон MVVM.

Blazor. Новейший фреймворк, позволяющий писать интерактивный веб-интерфейс на C# вместо JavaScript. Доступен в серверной (на основе SignalR) и WebAssembly версиях. Не заменяет все фронтенд-фреймворки, но привлекателен для команд, которые хотят оставаться в C#.

Итого: что на что заменено
Веб-интерфейс: Веб-формы → MVC → Razor Pages/минимальные API.
Сервисы: WCF → Web API → gRPC.
Структура проекта: Многоуровневая архитектура → Чистая архитектура.
Топология развёртывания: Монолит → Микросервисы → Модульный монолит.

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

Источник:
https://todayamerican.medium.com/net-c-application-architecture-over-time-7218f0470a02
👍9👎1
День 2655. #ЧтоНовенького
Атрибут ConfigurationIgnore в .NET 11
В Microsoft.Extensions.Configuration атрибут ConfigurationKeyNameAttribute существует с .NET 6 и позволяет переименовывать ключ, к которому привязано свойство. Но официального способа указать «не привязывать это свойство вообще» никогда не было. Этот пробел наконец-то устранён в .NET 11 с помощью ConfigurationIgnoreAttribute.

Проблема
Допустим, у вас есть класс параметров, который выглядит примерно так:
public class CsvIngestionOptions
{
// Вычисляется после загрузки – НЕ должен идти из конфигурации
public CsvFormatOptions DefaultFormat { get; set; }

// Раздел конфигурации, который мы привязываем и обрабатываем
public IConfigurationSection? DefaultFormatSection { get; set; }

// Вызывается после загрузки конфигурации, чтобы применить постобработку и значения по умолчанию
internal void OnConfigurationLoaded()
{
DefaultFormat = new CsvFormatOptions();
DefaultFormatSection?.Bind(DefaultFormat);
DefaultFormat.EnsureEncodingDefined();
}
}

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

Единственным обходным путём до .NET 11 было злоупотребление ConfigurationKeyNameAttribute с намеренно некорректным ключом:
// Костыль
[ConfigurationKeyName("__ignored_" + nameof(DefaultFormat))]
public CsvFormatOptions DefaultFormat { get; set; }

Это ненадёжно, вводит в заблуждение и создаёт странный код в вашей схеме конфигурации.

Решение
.NET 11 добавляет специальный атрибут ConfigurationIgnoreAttribute в Microsoft.Extensions.Configuration. Просто добавляем атрибут к тому свойству, которое не должно быть привязано:
public class CsvIngestionOptions
{
[ConfigurationIgnore]
public CsvFormatOptions DefaultFormat { get; set; }

[ConfigurationKeyName(nameof(DefaultFormat))]
public IConfigurationSection? DefaultFormatSection { get; set; }
// …
}


Ещё один распространённый сценарий
Постобработка — наиболее очевидный, но не единственный вариант использования. Ещё один классический пример — парсинг исходного значения:
public class FeatureFlags
{
public string RawFlags { get; set; } = string.Empty;

[ConfigurationIgnore]
public IReadOnlyDictionary<string, bool>
ParsedFlags { get; set; }
= new Dictionary<string, bool>();
}


Можно ли просто использовать [JsonIgnore]?
Нет, в этом и проблема. System.Text.Json.Serialization.JsonIgnoreAttribute не влияет на связыватель конфигурации.

Замечание: начиная с .NET 9, связыватель уже пропускает свойства только для чтения (только-get/только-init при отсутствии соответствующего раздела). Предлагаемый здесь атрибут предназначен для свойств, доступных для записи, которые могут быть связаны, но не должны быть связаны.

См. также обсуждение проблемы на GitHub.

Источник:
https://steven-giesel.com/blogPost/18a61100-6074-43ac-86ae-573ad66a2c8a/configurationignoreattribute-in-net-11
День 2656. #SystemDesign101
Data Warehouse, Data Lake или Data Mesh
Хранение данных — это просто. Настоящая проблема — решить, где и как их организовать.

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

Озеро данных (Data Lake) использует противоположный подход. Хранит все данные в необработанном виде, например, базы данных, журналы, изображения и видео. Обрабатывает их по мере необходимости. Гибкость — это здорово, но, если правила именования, форматирования и владения данными не установлены должным образом, вы получите дублирующиеся, устаревшие и недокументированные данные, которыми трудно управлять.

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

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

Источник:
https://bytebytego.com/
👎1
День 2657. #ВопросыНаСобеседовании
Марк Прайс предложил свой набор из 60 вопросов (как технических, так и на софт-скилы), которые могут задать на собеседовании.

33. Разработка веб-API
«Расскажите, как бы вы спроектировали и реализовали веб-API, используя возможности минимальных API? Опишите шаги, необходимые для создания минимального API, и как это упрощает разработку API по сравнению с более ранними версиями Web API».

Хороший ответ
Минимальные API обеспечивают упрощённый подход к созданию высокопроизводительных, легковесных HTTP API. Вот как я бы спроектировал и реализовал минимальный API.

1. Создать новый проект Web API можно с помощью команды: dotnet new webapi

2. В Program.cs создадим нужные конечные точки. Минимальные API используют лямбда-выражения для обработки запросов непосредственно в коде, что упрощает маршрутизацию и настройку контроллера:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/products", async (AppDbContext db) =>
await db.Products.ToListAsync());

app.MapGet("/products/{id}",
async (int id, AppDbContext db) =>
await db.Products.FindAsync(id) is Product product ?
Results.Ok(product) : Results.NotFound());

app.MapPost("/products",
async (Product product, AppDbContext db) =>
{
db.Products.Add(product);
await db.SaveChangesAsync();
return Results.Created($"/products/{product.Id}", product);
});

//…

app.MapDelete("/products/{id}",
async (int id, AppDbContext db) =>
{
if (await db.Products.FindAsync(id) is Product product)
{
db.Products.Remove(product);
await db.SaveChangesAsync();
return Results.Ok(product);
}
return Results.NotFound();
});

app.Run();


3. Настроим необходимые сервисы, такие как контекст БД, в настройках конструктора:
builder.Services.AddDbContext<AppDbContext>(opts =>
opts.UseSqlServer(builder.Configuration
.GetConnectionString("DefaultConnection")));


4. Тестировать API можно с помощью Postman или Swagger. .NET поддерживает Swagger по умолчанию:
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();


Преимущества минимальных API
- Уменьшение шаблонного кода: устраняет необходимость в отдельных контроллерах, делая кодовую базу проще и меньше.
- Простота использования: упрощает настройку маршрутизации, облегчая создание и управление API.
- Производительность: предлагает легковесную альтернативу традиционным MVC-архитектурам, потенциально повышая производительность. Проекты минимальных API могут быть скомпилированы с использованием нативного AOT для ещё большей производительности.
Этот подход использует новейшие возможности .NET для эффективного создания API, фокусируясь на простоте и производительности.

Часто встречающийся плохой ответ
«Минимальные API подходят только для тестов и самых простых проектов и не предлагают ничего такого, чего не могли бы сделать контроллеры. Лучше придерживаться стандартного шаблона MVC».

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

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

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

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

Источник:
https://github.com/markjprice/tools-skills-net8/blob/main/docs/interview-qa/readme.md
👎11👍2
День 2658. #Карьера
Дорожная Карта .NET Разработчика в 2026. Начало

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

I. Основы (обязательно)
Перед специализацией каждый .NET-разработчик должен освоить общий набор фундаментальных принципов. Их пропуск приводит к хрупкости знаний и медленному карьерному росту.

1. Основы разработки
- Как работает веб (запросы, ответы, методы HTTP);
- Базовые концепции работы с сетью;
- Принципы чистого кода и ООП;
- Системы контроля версий Git (ветвления, коммиты, пул-реквесты).
Эти навыки применимы везде, а не только в .NET.

2. Основы .NET и C#
- Современный синтаксис и особенности языка C#;
- Концепции среды выполнения .NET;
- Использование CLI для сборки и запуска проектов;
- Уверенная работа в IDE (Visual Studio, VS Code, Rider).
Не спешите с этим шагом. Прочные основы здесь окупятся на долгие годы.

3. Создание первого бэкенда
- Создание простого веб-API;
- Понимание маршрутизации, контроллеров и внедрения зависимостей;
- Подключение к реляционной БД;
- Выполнение базовых CRUD-операций;
- Использование ORM и понимание, что происходит «под капотом».
Цель — не совершенство, а уверенность.

4. ИИ как помощник в программировании
Инструменты ИИ могут ускорить повторяющиеся задачи, предложить решения и помочь быстро исследовать новые паттерны. Разбирайте генерируемый код, проверяйте его и интегрируйте продуманно. Думайте об ИИ как о помощнике, который повышает производительность, а не о чём-то, что пишет код за вас. Чем прочнее ваши базовые знания, тем эффективнее вы сможете использовать ИИ, не теряя контроля. Используйте ИИ для:
- Изучения идей;
- Повышения продуктивности;
- Быстрого выявления закономерностей.

II. Выбор направления
Настало время специализации. Не нужно изучать всё, нужно изучать то, что соответствует вашим целям.

1. Путь бэкенд-разработчика
Работа с API, данными, производительностью и масштабируемостью.
Ключевые навыки:
- Проектирование API и лучшие практики;
- Аутентификация и авторизация;
- Обработка ошибок и логирование;
- Валидация и чистая архитектура;
- Кэширование и оптимизация производительности;
- Фоновая обработка;
- Модульное и интеграционное тестирование.
Бэкенд-разработчики отвечают за надёжность и корректность — здесь глубина знаний важнее широты.

2. Путь Blazor-разработчика
Создание интерактивных веб-приложений на C#.
Ключевые навыки:
- Разработка компонентного UI;
- Маршрутизация и проектирование компоновки;
- Обработка и валидация форм;
- Стратегии управления состоянием;
- Фреймворки и стилизация UI;
- Основы JavaScript-интеропа;
- Тестирование компонентов UI.
Этот путь хорошо подходит для корпоративных приложений, панелей мониторинга и внутренних инструментов.

3. Путь фулстек-разработчика
Объединение бэкенд API с фронтенд-приложениями.
Ключевые навыки:
- Проектирование API;
- Создание UI, использующего API;
- Обработка сквозной аутентификации;
- Управление общими моделями и контрактами;
- Понимание как производительности, так и пользовательского опыта.
Этот путь требует баланса — не поверхностных знаний, а универсальности.

Окончание следует…

Источник:
https://www.c-sharpcorner.com/article/a-practical-net-developer-roadmap-for-2026/
👍8👎2
День 2659. #Карьера
Дорожная Карта .NET Разработчика в 2026. Окончание

Начало

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

1. Проектирование и архитектура систем
- Структура и модульность приложений;
- Компромиссы между монолитами и распределёнными системами;
- Шаблоны масштабируемости и отказоустойчивости;
- Мониторинг и диагностика.

2. Контейнеры и доставка
Современное ПО не ограничивается принципом «работает на моей машине»:
- Концепции контейнеризации;
- Локальные и производственные среды;
- Автоматизированные сборки и развёртывания;
- Понимание конвейеров выпуска.

3. Облачные технологии
- Как размещаются приложения в облаке;
- Конфигурация среды;
- Основы безопасности;
- Вопросы стоимости и производительности.

4. Инструменты, упрощающие жизнь
Библиотеки и инструменты для:
- Логирования;
- Валидации;
- Маппинга;
- Тестирования;
- Фоновых задач;
- UI-компонентов.
Инструменты меняются. Концепции остаются. Сосредоточьтесь на том, почему они вам нужны, а не только на том, как их использовать.

IV. Часто игнорируемый навык: Коммуникация
Отличные разработчики:
- Пишут чёткие сообщения коммитов;
- Просто объясняют технические решения;
- Документируют системы для будущих коллег;
- Задают правильные вопросы.
Эти навыки часто важнее, чем знание ещё одного фреймворка.

Последовательность обучения
1. Git и основы программирования
2. Основы C#
3. Основы ASP.NET Core
4. Базы данных и доступ к данным
5. Выбор специализации
6. Создание реальных проектов
7. Развёртывание и архитектура

Итого
В разработке ПО нет финишной линии. Цель не в том, чтобы «знать всё», а в том, чтобы стать человеком, способным постоянно учиться и решать важные проблемы. Будьте последовательны. Создавайте. Размышляйте.

Источник: https://www.c-sharpcorner.com/article/a-practical-net-developer-roadmap-for-2026/
👍11👎2
День 2660. #ЗаметкиНаПолях
Отключаем HTTP-Кэширование по Умолчанию в
ASP.NET Core API
При создании API в ASP.NET Core крайне важно явно контролировать поведение кэширования. В отличие от веб-страниц, где кэширование часто улучшает пользовательский опыт, ответы API не следует кэшировать по умолчанию, если вы намеренно не предусмотрели возможность их кэширования. Непреднамеренное кэширование может привести к серьёзным проблемам, включая устаревшие данные, уязвимости безопасности и трудновоспроизводимые ошибки.

Стандарты кэширования в HTTP
Кэширование HTTP регулируется RFC 7234 (Кэширование в HTTP/1.1) и RFC 9111 (HTTP Кэширование). В соответствии с этими спецификациями, кэши разных уровней могут хранить ответы и предоставлять их без обращения к исходному серверу, используя заголовки, такие как Cache-Control, Expires, ETag и Last-Modified.

При отсутствии заголовков кэши могут применять эвристическое истечение срока действия, кэшируя ответы API даже без явных на то указаний. Это особенно проблематично, поскольку браузеры и промежуточные кэши (такие как CDN, прокси или кэши шлюзов) могут использовать собственные алгоритмы для определения того, как долго хранить ответ.

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

Вот как создать такое промежуточное ПО:
internal sealed class 
NoCacheMiddleware(RequestDelegate next)
{
public async Task InvokeAsync(HttpContext ctx)
{
ctx.Response.OnStarting(() =>
{
// Устанавливаем заголовки no-cache, только если не были установлены явно
if (ctx.Response.Headers.CacheControl.Count is 0)
ctx.Response.Headers.CacheControl =
"no-cache,no-store,must-revalidate";

return Task.CompletedTask;
});

await next(ctx);
}
}

Регистрируем наше промежуточное ПО в конвейере:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseMiddleware<NoCacheMiddleware>();

app.MapGet("/", () => "Hello World!");
app.Run();


Источник: https://www.meziantou.net/disable-http-caching-by-default-in-asp-net-core-apis.htm
👍11👎1
День 2661. #МоиИнструменты #PG
Инструменты Оптимизации Запросов в PostgreSQL. Часть 9


9. HypoPG (Гипотетические индексы для PostgreSQL)
Что даёт: тестирование влияния индексов без их создания.

Зачем нужен
Создание индексов на больших таблицах — дорогостоящий процесс. HypoPG позволяет тестировать эффективность индексов (видеть изменения плана запроса) без их фактического создания.

Использование
-- Установка расширения
CREATE EXTENSION hypopg;


1. Анализируем долгий запрос:
EXPLAIN ANALYZE
SELECT * FROM orders
WHERE customer_id = 12345
AND order_date >= '2024-01-01';

Результат:
Seq Scan on orders (cost=0.00..185234.25) (actual time=2341.234ms)


2. Создаём гипотетический индекс:
SELECT hypopg_create_index('CREATE INDEX ON orders(customer_id, order_date)');
-- Вывод: (18001,"<18001>btree_orders(customer_id, order_date)")

ID индекса: 18001

3. Анализируем запрос повторно. Результат:
Index Scan using <18001>btree_orders (cost=0.43..8.45) (actual time=0.112ms)

Улучшение производительности: 2341мс → 0,112мс (в 20000 раз быстрее)
Решение: создать реальный индекс.

4. Удаляем гипотетический индекс и создаём реальный.
SELECT hypopg_drop_index(18001);

CREATE INDEX CONCURRENTLY idx_orders_customer_date
ON orders(customer_id, order_date);


Тестируем разные варианты индекса
Когда неясно, какой индекс лучше:
-- 1: (customer_id, order_date)
SELECT hypopg_create_index('CREATE INDEX ON orders(customer_id, order_date)');
EXPLAIN SELECT … FROM orders WHERE customer_id = ? AND order_date >= ?;
-- Cost: 8.45

-- 2: (order_date, customer_id) – другой порядок
SELECT hypopg_reset(); -- Удаляем предыдущие гипот. индексы
SELECT hypopg_create_index('CREATE INDEX ON orders(order_date, customer_id)');
EXPLAIN SELECT … FROM orders WHERE customer_id = ? AND order_date >= ?;
-- Cost: 12.34

-- 3: Частичный (только последние заказы)
SELECT hypopg_reset();
SELECT hypopg_create_index('CREATE INDEX ON orders(customer_id) WHERE order_date >= ''2024-01-01''');
EXPLAIN SELECT … FROM orders WHERE customer_id = ? AND order_date >= '2024-01-01';
-- Cost: 6.12 (лучше!)

-- Создаём оптимальный индекс
CREATE INDEX CONCURRENTLY idx_orders_customer_recent
ON orders(customer_id)
WHERE order_date >= '2024-01-01';


Когда использовать
- Большие таблицы (создание индекса дорого);
- Не уверены, какой индекс создать;
- Хотите протестировать перед внедрением в прод;
- База в проде (нельзя экспериментировать).

Когда отказаться
- Небольшие таблицы (просто создайте индекс, это быстро);
- Очевидно, какой индекс нужен.

Скрытая функция
Автоматическая рекомендация индекса на основе рабочей нагрузки запросов (совместно с pg_stat_statements):
CREATE EXTENSION pg_stat_statements;
CREATE EXTENSION hypopg;
-- Ищем запросы, которым нужны индексы
SELECT
calls,
total_exec_time,
query,
hypopg_create_index(
'CREATE INDEX ON ' ||
regexp_replace(query, '^.*FROM\s+(\w+).*WHERE\s+(\w+)\s*=.*',
'\1(\2)')
) AS suggested_index
FROM pg_stat_statements
WHERE calls > 100
AND total_exec_time > 10000 -- 10+ секунд
AND query ~* 'WHERE.*=' -- Содержат WHERE
ORDER BY total_exec_time DESC
LIMIT 10;

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

С осторожностью
Гипотетические индексы сохраняются в сессии и влияют на все запросы в сессии.
SELECT hypopg_create_index('CREATE INDEX ON orders(customer_id)');
-- …
-- Позже в той же сессии:
EXPLAIN SELECT * FROM orders;

EXPLAIN использует гипотетический индекс, что исказит результаты.

Решения
1. Использовать отдельную сессию для тестов;
2. Удалять гипотетические индексы после тестов:
SELECT hypopg_reset();

3. Использовать транзакции:
BEGIN;
SELECT hypopg_create_index(…);
EXPLAIN SELECT …;
ROLLBACK; -- Очистит гипот. индексы


Источник: https://medium.com/@reliabledataengineering/15-sql-optimization-tools-that-make-queries-10x-faster-8629ac451d97
👍11
День 2662. #ЧтоНовенького #NET11
В .NET 11 Исключения Фоновых Сервисов Будут Всплывать
Ошибка, которая давно существовала в .NET: если BackgroundService генерировал исключение после первого await, хост перехватывал его, писал критическое сообщение в лог, а затем корректно завершал работу с кодом результата 0. Т.е. все думали, что процесс успешно завершился. Теперь это исправлено!
 
Проблема
Рассмотрим этот рабочий процесс:
public class Worker : BackgroundService
{
  protected override async Task
   ExecuteAsync(CancellationToken stopToken)
  {
    await Task.Delay(TimeSpan.FromSeconds(1), stopToken);
    throw new Exception("something went wrong");
  }
}

До .NET 11 вывод был таким:
crit: Microsoft.Extensions.Hosting.Internal.Host[10]
      The HostOptions.BackgroundServiceExceptionBehavior is configured to StopHost.
      A BackgroundService has thrown an unhandled exception, and the IHost instance is stopping.
      ...
      System.Exception: something went wrong
info: Microsoft.Hosting.Lifetime[0]
      Application is shutting down...

Процесс завершён с кодом 0 ??? Критическая ошибка в логе, но код результата всё равно 0.
 
Почему это так работало?
Если метод помечен как асинхронный, исключение перехватывалось функцией TryExecuteBackgroundServiceAsync глубоко внутри инфраструктуры, логировалось как критическое, после чего хост инициировал корректное завершение работы. Корректное завершение работы => код результата 0.
Если метод не помечен как асинхронный и выбрасывалось исключение, то процесс завершался с кодом ошибки.
 
Основная причина в том, что host.RunAsync() возвращает Task (а не Task<int>), и не было механизма для сигнализации о завершении процесса с кодом ошибки для фонового сервиса, который бы указывал на сбой.
 
Исправление в .NET 11
Теперь IHost.RunAsync() и IHost.StopAsync() будут передавать исключение из BackgroundService, а не игнорировать его. Теперь вы получите:
crit: Microsoft.Extensions.Hosting.Internal.Host[10]
      …
      System.Exception: something went wrong
 
Unhandled exception. System.Exception: something went wrong
   at Worker.ExecuteAsync(…)
 
Process finished with exit code 134. (или 1 в Windows)

 
Если вам нужно старое поведение
Вы можете установить для параметра обработки исключений значение «Игнорировать»:
services.Configure<HostOptions>(options =>
{
    options.BackgroundServiceExceptionBehavior = BackgroundServiceExceptionBehavior.Ignore;
});

 
См. оригинальный ишью.
 
Источник: https://steven-giesel.com/blogPost/00fcb870-6bf7-4f97-824f-8eab1b8838be/backgroundservice-exceptions-now-propagate-in-net-11
👍17
День 2663. #ЗаметкиНаПолях #DDD
Что Такое Инварианты? Начало

Во многих «DDD-подобных» кодовых базах .NET бизнес правила разбросаны по обработчикам, валидаторам и контроллерам, и почти не затрагивают саму доменную модель. Каждая копия одного и того же правила со временем немного меняется, и валидность данного объекта начинает зависеть от того, каким путём вызывающий код к нему добрался. Вы, безусловно, можете построить работающую систему таким образом. Но есть более чистый способ, и он начинается с одной идеи.

Что такое инвариант?
Инвариант — это правило об объекте, которое должно оставаться верным до тех пор, пока объект существует.

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

Несколько примеров:
- У курса всегда есть непустое название.
- Итоговая сумма заказа всегда равна сумме стоимостей позиций в нём.
- Подписка находится ровно в одном состоянии: пробная, активная, истекшая или отменённая.

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

Где процедурный код дает сбои
Возьмём простой курс, написанный так, как это до сих пор делают большинство CRUD-подобных .NET-приложений:
public class Course
{
public string Title { get; set; }
public CourseStatus Status { get; set; }
public DateTime? PublishedOn { get; set; }
public decimal Price { get; set; }
}

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

Чтобы данные оставались корректными, правила разбросаны по всему приложению:
- CreateCourseValidator проверяет, не пуст ли заголовок.
- PublishCourseHandler устанавливает статус «Опубликован» и дату PublishedOn и не забывает проверить, не был ли курс уже в статусе «Опубликован».
- ChangePriceHandler проверяет, не отправлен ли курс в архив.
Появляется новая конечная точка, кто-то копирует существующий обработчик, и проверка архивности незаметно исчезает.
Каждое правило находится в месте, которое случайно оказывается на пути запроса. Ничто в самом классе Course не мешает ему перейти в недействительное состояние.

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

Решение простое: модель никогда не должна принимать недействительное состояние.

Если у вас есть ссылка на Course, вы можете ей доверять. Вам не нужна проверка if (course.Title is null), не нужно вызывать валидатор и не нужно надеяться, что обработчик до вас выполнил правильную проверку.

Окончание следует…

Источник:
https://www.milanjovanovic.tech/blog/what-invariants-are-and-why-a-domain-model-is-the-best-place-to-enforce-them
👍15👎1
День 2664. #ЗаметкиНаПолях #DDD
Что Такое Инварианты? Окончание

Начало

Модель как источник истины
Три шага к цели
1. Запрет создания недействительных объектов
Курс без названия не должен существовать — делаем это невозможным:
public class Course
{
private Course(CourseId id, string title, Money price)
{
Id = id;
Title = title;
Price = price;
Status = CourseStatus.Draft;
}

public static Result<Course>
Create(string title, Money price)
{
if (string.IsNullOrWhiteSpace(title))
return CourseErrors.TitleRequired;

return new Course(CourseId.New(), title, price);
}

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

2. Инкапсуляция переходов состояния
Класс должен контролировать, как он изменяется, вместо того чтобы оставлять это на усмотрение его обработчиков. Никаких сеттеров, и каждое изменение проходит через метод, который знает правила:
public Result Publish(IDateTimeProvider clock)
{
if (Status != CourseStatus.Draft)
return CourseErrors.AlreadyPublished;

if (_lessons.Count == 0)
return CourseErrors.CannotPublishWithoutLessons;

Status = CourseStatus.Published;
PublishedOn = clock.UtcNow;
return Result.Success();
}

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

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

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

Неправильный подход — предоставлять Lessons как изменяемую коллекцию и полагаться на то, что обработчики будут соблюдать правило везде. Правильный подход — держать коллекцию приватной и принудительно обрабатывать каждое изменение через корень агрегата:
public class Course
{
private readonly List<Lesson> _lessons = [];
public IReadOnlyCollection<Lesson>
Lessons => _lessons.AsReadOnly();

public Result RemoveLesson(LessonId id)
{
if (Status == CourseStatus.Published)
return CourseErrors.CannotModifyPublishedLessons;

var lesson = _lessons.FirstOrDefault(l => l.Id == id);
if (lesson is null)
return CourseErrors.LessonNotFound;

_lessons.Remove(lesson);
return Result.Success();
}
}

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

Итого
Можно написать ту же систему процедурно, и она может хорошо работать, но вы теряете доверие. В процедурной системе каждый вызывающий объект несёт ответственность за то, чтобы не нарушать правила. В постоянно действительной модели эта ответственность лежит на самой модели. Разница накапливается со временем:
- Валидаторы не меняются, потому что нечего дублировать.
- Проверки кода фокусируются на поведении, а не на «не забыли ли мы проверить Х?».
- Новые конечные точки не могут случайно обойти правило, находящееся в сущности.
- В тестах не нужно проверять недействительные сценарии.
- Модель из пассивного носителя данных превращается в минимальное и чёткое место хранения бизнес-правил.

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

Источник:
https://www.milanjovanovic.tech/blog/what-invariants-are-and-why-a-domain-model-is-the-best-place-to-enforce-them
👍9👎1
Please open Telegram to view this post
VIEW IN TELEGRAM
День 2665. #ЧтоНовенького #NET11
Улучшения API процессов в .NET 11. Обзор
Класс System.Diagnostics.Process — это основной способ создания процессов и взаимодействия с ними в .NET. В .NET 11 в него внесли самое масштабное обновление за последние годы. Изменения добавляют высокоуровневые API, которые упрощают запуск процесса и перехват его вывода без взаимоблокировок, предоставляют полный контроль над наследованием дескрипторов и стандартным перенаправлением дескрипторов, вводят функции управления временем жизни, такие как KillOnParentExit, и включают в себя облегченный API на основе SafeProcessHandle, более удобный для оптимизации. В этой серии постов рассмотрим нововведения подробно.

Новые функции
1. Однострочник для выполнения процесса - Process.RunAndCaptureText[Async]
Запускает процесс, перехватывает вывод/ошибку, ожидает завершения — всё за один вызов.

2. Выполнение без перехвата вывода - Process.Run[Async]
Запускает процесс и ожидает завершения без перехвата вывода.

3. Запустить и забыть - Process.StartAndForget
Запускает процесс, возвращает его PID и немедленно освобождает все ресурсы.

4. Перехват вывода без взаимоблокировок - Process.ReadAllText/Bytes/Lines[Async]
Читает stdout и stderr одновременно с использованием мультиплексирования, избегая взаимоблокировок буфера канала.

5. Перенаправление - ProcessStartInfo.Standard[Input/Output/Error]Handle
Перенаправляет стандартные дескрипторы на файлы, каналы, null или любой SafeFileHandle.

6. Контролируемое наследование - ProcessStartInfo.InheritedHandles
Точно указывает, какие дескрипторы наследуются дочерними процессами, предотвращая случайные утечки памяти.

7. Завершение при выходе родительского процесса - ProcessStartInfo.KillOnParentExit
Гарантирует завершение дочерних процессов при выходе родительского процесса (Windows и Linux).

8. Отсоединённые процессы - ProcessStartInfo.StartDetached
Запускает процесс, который сохраняется после выхода родительского процесса, сигнала или закрытия терминала.

9. Легковесный дескриптор процесса - SafeProcessHandle.Start/WaitForExit/Kill/Signal
Удобный для сокращения количества процессов низкоуровневый API для запуска и управления процессами без Process.

10. Подробная информация о завершении процесса - ProcessExitStatus
Сообщает код завершения, сигнал завершения (Unix) и был ли процесс завершён из-за тайм-аута/отмены.

11. Нулевой дескриптор - File.OpenNullHandle()
Открывает дескриптор, который отбрасывает операции записи и возвращает EOF при чтении.

12. Анонимные каналы - SafeFileHandle.CreateAnonymousPipe
Создаёт пару подключённых каналов с дополнительной поддержкой асинхронности.

13. Обработчики консоли - Console.OpenStandard[Input/Output/Error]Handle()
Получает базовый дескриптор операционной системы для стандартных потоков.

14. Определение типа дескриптора - SafeFileHandle.Type
Определяет, является ли дескриптор файлом, каналом, сокетом и т. д.

Далее рассмотрим новые функции подробнее.

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

Источник:
https://devblogs.microsoft.com/dotnet/process-api-improvements-in-dotnet-11/
👍14