Библиотека шарписта | C#, F#, .NET, ASP.NET

📎 Task.Run внутри ASP.NET пайплайна Один из самых распространённых антипаттернов в .NET, который выглядит как хорошая практика, но на деле замедляет систему. Обычный код:

await Task.Run(() => _logger.LogInformation("Processing..."));
await Task.Run(() => MapToDto(entity));
await Task.Run(() => ValidateHeaders(request));

Выглядит современно и async везде. Что происходит на самом деле Каждый Task.Run внутри ASP.NET запроса: — ставит задачу в очередь thread pool — вызывает context switch — добавляет scheduling overhead При этом ASP.NET уже работает на оптимально управляемом thread pool. Вы не освобождаете поток, а создаёте дополнительную нагрузку на планировщик. Как надо:

// Логирование — всегда синхронно
_logger.LogInformation("Processing...");

// Маппинг — синхронно
var dto = MapToDto(entity);

// Валидация заголовков — синхронно
ValidateHeaders(request);

// async оставляем только для реального I/O
var data = await _repository.GetAsync(id);
var response = await _httpClient.GetAsync(url);

Есть ситуация, где он оправдан: долгая CPU-bound работа, которую нужно вынести за пределы потока запроса, чтобы не блокировать пайплайн. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

🤩 Подборка вакансий для шарпистов C# Backend Developer — от 180 000 ₽ гибрид в Санкт-Петербурге Unity разработчик — до 4 500 €, гибрид в Алматы Fullstack-разработчик (C# / React Native) — удалёнка или гибрид в Пензе ➡️ Еще больше топовых вакансий — в нашем канале C# Jobs 🐸 Библиотека шарписта

⚡️ Никаких больше var Microsoft официально объявила: в C# 15 ключевое слово var признаётся устаревшим. Команда языка ссылается на исследования читаемости кода: оказывается, явное указание типов снижает когнитивную нагрузку на 34% и ускоряет код ревью. Roslyn уже умеет автоматически выводить тип, но теперь хочет, чтобы это делал и программист. Миграция через dotnet-upgrade-assistant проставит типы автоматически. Но 40 000 строк кода всё равно ждут вас в ближайшем будущем. ➡️ Источник Попались? С первым апреля!😁 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта

🚩 OpenFeature для .NET Смена провайдера feature flags обычно означает переписывание интеграции. OpenFeature это открытый стандарт под крылом CNCF, который даёт единый vendor-agnostic API: меняете провайдера, меняете одну строчку, код не трогаете. Установка

dotnet add package OpenFeature

Требования: .NET 8+ или .NET Framework 4.6.2+ Минимальный пример:

await Api.Instance.SetProviderAsync(new InMemoryProvider());

var client = Api.Instance.GetClient();
bool v2Enabled = await client.GetBooleanValueAsync("v2_enabled", false);

if (v2Enabled)
{
    // новая логика
}

Флаги с контекстом Передавайте данные о пользователе/запросе для контекстно-зависимых решений:

// Глобально
EvaluationContext ctx = EvaluationContext.Builder()
    .Set("region", "us-east-1")
    .Build();
Api.Instance.SetContext(ctx);

// Или прямо в вызове
bool flagValue = await client.GetBooleanValueAsync(
    "some-flag", false, reqCtx);

Логика вокруг вычисления флага Добавляйте поведение на любом этапе: до, после, при ошибке, в любом случае.

// Глобально для всех вызовов
Api.Instance.AddHooks(new ExampleGlobalHook());

// Только для конкретного клиента
client.AddHooks(new ExampleClientHook());

Встроенный LoggingHook пишет детальные логи через Microsoft.Extensions.Logging. Реакция на изменения

Api.Instance.AddHandler(
    ProviderEventTypes.ProviderReady,
    (eventDetails) => Console.WriteLine(eventDetails.Type)
);

Подписывайтесь на ProviderReady, ProviderError, ProviderConfigurationChanged. Dependency Injection (экспериментально)

dotnet add package OpenFeature.Hosting

builder.Services.AddOpenFeature(featureBuilder => {
    featureBuilder
        .AddInMemoryProvider()
        .AddHook<LoggingHook>();
});

Поддержка domain-scoped провайдеров: разные провайдеры для разных частей приложения. Несколько провайдеров одновременно с разными стратегиями: - FirstMatchStrategy — первый ненулевой результат - FirstSuccessfulStrategy — первый успешный, игнорируя ошибки - ComparisonStrategy — параллельное выполнение + сравнение результатов

var multiProvider = new MultiProvider(providerEntries, new FirstMatchStrategy());
await Api.Instance.SetProviderAsync(multiProvider);

Собственный провайдер:

public class MyProvider : FeatureProvider
{
    public override Metadata GetMetadata() =>
        new Metadata("My Provider");

    public override Task<ResolutionDetails<bool>> ResolveBooleanValueAsync(
        string flagKey, bool defaultValue,
        EvaluationContext? context = null, ...)
    {
        // ваша логика
    }
    // + ResolveString, ResolveInteger, ResolveDouble, ResolveStructure
}

Для ASP.NET Core один раз настроили контекст на входе запроса, и он автоматически попадает во все вычисления флагов в рамках этого запроса:

Api.Instance.SetTransactionContextPropagator(
    new AsyncLocalTransactionContextPropagator());

📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

🚫 Span<T> и async несовместимы Span<T> это ref struct. А ref struct не может существовать в куче. Это не ограничение реализации, это гарантия безопасности по дизайну. Async-методы компилятор превращает в state machine — объект, который живёт в куче и может приостанавливаться между await-точками. Локальные переменные такого метода становятся полями этого объекта. Поле типа ref struct в объекте на куче — запрещено. Поэтому компилятор просто не даст использовать Span<T> в async-методе.

// Не скомпилируется
async Task ProcessAsync(byte[] data)
{
    Span<byte> span = data; // CS4012: Span нельзя использовать в async
    await Task.Delay(100);
    Process(span);
}

Что происходит под капотом Компилятор превращает async-метод примерно в это:

// Упрощённо — что генерирует компилятор
private struct ProcessAsyncStateMachine : IAsyncStateMachine
{
    public byte[] data;
    public Span<byte> span; // ← невозможно: ref struct не может быть полем
    public int _state;
    // ...
}

Стек фрейм между await не гарантирован, потому что поток может смениться, метод может возобновиться на другом потоке. Span на стеке к тому моменту уже не существует. Как работать с данными в async-коде Memory<T> — это то, для чего он и создан. Может жить в куче, передаётся через await, конвертируется в Span в синхронных участках:

async Task ProcessAsync(Memory<byte> memory)
{
    await Task.Delay(100); // можно
 
    // Span получаем только там, где нет await
    Span<byte> span = memory.Span;
    Process(span);
}

Паттерн: Memory<T> для хранения и передачи через async-границы, Span<T> для фактической работы с данными в синхронном контексте.

async Task<int> ReadAndProcessAsync(Stream stream)
{
    // Memory живёт в куче — await доволен
    var buffer = new byte[4096];
    Memory<byte> memory = buffer;
 
    int bytesRead = await stream.ReadAsync(memory);
 
    // Переходим в sync-контекст — достаём Span
    Span<byte> span = memory.Span[..bytesRead];
    return CountNewlines(span);
}
 
static int CountNewlines(Span<byte> data)
{
    int count = 0;
    foreach (var b in data)
        if (b == '\n') count++;
    return count;
}

Коротко Span<T> — инструмент для горячего пути в синхронном коде. Как только появляется await переходите на Memory<T> и конвертируйте в Span только там, где он нужен непосредственно для вычислений. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #garbage_collector

🎶 Разработчик написал программу для управления самодельным проигрывателем винила Разработчик с Reddit строит автоматический проигрыватель пластинок с нуля: механику, электронику и прошивку для STM32. Чтобы тестировать и отлаживать железо в процессе разработки, он написал десктопное управляющее приложение на C#. Приложение позволяет управлять проигрывателем с компьютера, снимать статистику и диагностировать проблемы на лету — по сути, это инструментарий для разработчика железа, написанный на том же языке, что и обычный бизнес-софт. Для него это первый опыт написания control software для физического железа и судя по его словам, ощущение от того, что код управляет реальным устройством в реальном мире, совершенно другое. ➡️ Источник 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #entry_point

💡 Красивые алгоритмы медленны при малом n Красивые алгоритмы с хорошей асимптотикой имеют большие константы. O(log n) звучит лучше O(n), но если n=20 — линейный поиск по массиву быстрее бинарного поиска по дереву просто потому, что данные помещаются в кэш процессора и нет накладных расходов на обход структуры. Допустим, нужно найти обработчик по типу события. Первый импульс это словарь или дерево:

// "Правильное" решение — O(1) lookup
private readonly Dictionary<string, IHandler> _handlers = new()
{
    ["OrderCreated"] = new OrderCreatedHandler(),
    ["OrderCancelled"] = new OrderCancelledHandler(),
    ["OrderShipped"] = new OrderShippedHandler(),
};

// "Наивное" решение — O(n) linear scan
private readonly (string EventType, IHandler Handler)[] _handlers =
[
    ("OrderCreated", new OrderCreatedHandler()),
    ("OrderCancelled", new OrderCancelledHandler()),
    ("OrderShipped", new OrderShippedHandler()),
];

public IHandler? Find(string eventType)
{
    foreach (var (type, handler) in _handlers)
        if (type == eventType) return handler;
    return null;
}

При 5–20 обработчиках линейный массив часто быстрее словаря: данные лежат последовательно в памяти, нет хеширования, нет разыменования указателей, кэш доволен. Dictionary начинает выигрывать при десятках тысяч элементов и только тогда. Бенчмарк говорит сам за себя:

[MemoryDiagnoser]
public class LookupBenchmark
{
    private readonly Dictionary<string, int> _dict;
    private readonly (string, int)[] _array;

    public LookupBenchmark()
    {
        var data = Enumerable.Range(0, 10)
            .Select(i => ($"key{i}", i))
            .ToArray();

        _dict = data.ToDictionary(x => x.Item1, x => x.Item2);
        _array = data;
    }

    [Benchmark(Baseline = true)]
    public int DictLookup() => _dict["key7"];

    [Benchmark]
    public int ArrayScan()
    {
        foreach (var (k, v) in _array)
            if (k == "key7") return v;
        return -1;
    }
}

При n=10 массив зачастую быстрее и не аллоцирует ничего лишнего. Измерьте сами. Когда измерения при реальной нагрузке показывают, что n действительно большой и растёт. Не раньше. Routing-таблица с 15 маршрутами, валидация с 8 правилами, матчинг по 12 паттернам — всё это «малый n», и простой цикл здесь выиграет у любого красивого решения. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

👨‍💻 Разделяемое состояние в многопоточке Кажется, что примитивы атомарны. Это не так в смысле видимости между потоками: процессор и компилятор переупорядочивают инструкции, каждое ядро держит своё значение в кэше:

private bool _cacheLoaded;

// Поток A
_cacheLoaded = true;

// Поток B — может прочитать false, даже если A уже записал true
if (!_cacheLoaded) LoadCache(); // загружается дважды, данные затираются

Как это исправить 1. lock. Подходит для составных операций: «прочитать → изменить → записать» должны выполняться как одно целое:

private readonly object _sync = new object();
private int _count;

public void Increment()
{
    lock (_sync) { _count++; }
}

2. volatile. Запрещает кэширование значения в регистре. Не заменяет lock. Только для простого чтения/записи одного поля без зависимостей от других.

private int _count;

public void Increment()
{
    Interlocked.Increment(ref _count);
}

3. Interlocked. Атомарная операция на уровне процессора. Быстрее lock, но только для простых числовых операций:

private int _count;

public void Increment()
{
    Interlocked.Increment(ref _count);
}

📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

📰 Дайджест недели Последний дайджест марта. — Generative AI for Beginners .NET v2 — Почти год с Copilot Coding Agent в dotnet/runtime — Пять типичных ошибок при проектировании интеграции с помощью Kafka 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #async_news

⚙️ Substring или Slice Substring и Slice выглядят похоже, но работают принципиально по-разному. Substring — это new string(...). Каждый вызов: — выделяет новый объект в хипе — копирует символы в него — создаёт нагрузку на GC Slice не создаёт объектов. Это просто новый указатель + длина поверх той же памяти. int.Parse(ReadOnlySpan<char>) читает символы напрямую оттуда. Частая ошибка

// Так делать не надо — убивает весь смысл
int id = int.Parse(span.Slice(5, 2).ToString());

ToString() на Span создаёт новую строку. Вернулись к исходной проблеме. Одно правило: если Substring перед Parse это кандидат на замену. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

⚡️ Рестарт ради смены настроек это лишнее Если конфигурация меняется редко, перезапуск приложения — не проблема. Но когда нужно менять, например, тарифы или флаги в реальном времени, рестарт становится дорогим решением. IOptionsMonitor<T> позволяет получать актуальные значения сразу после изменения файла конфигурации. Как это работает IOptionsMonitor<T> следит за изменениями источника конфигурации. При каждом обращении к CurrentValue возвращается актуальное значение. Дополнительно можно подписаться на событие изменения через OnChange:

public class DynamicPricingService
{
    private readonly IOptionsMonitor<PricingOptions> _options;

    public DynamicPricingService(IOptionsMonitor<PricingOptions> options)
    {
        _options = options;

        _options.OnChange(updatedOptions =>
        {
            Log.Information("Pricing updated: BaseRate={BaseRate}",
                updatedOptions.BaseRate);
        });
    }

    public decimal CalculatePrice(decimal distance)
    {
        var currentOptions = _options.CurrentValue;

        return currentOptions.BaseRate + (distance * currentOptions.PerMileRate);
    }
}

Каждый вызов CalculatePrice берёт свежее значение из CurrentValue без рестарта и без ручного сброса кэша. Регистрация в Program.cs:

builder.Services.AddOptions<PricingOptions>()
    .BindConfiguration("Pricing", binderOptions =>
    {
        binderOptions.BindNonPublicProperties = false;
        binderOptions.ErrorOnUnknownConfiguration = true;
    })
    .ValidateDataAnnotations();

ErrorOnUnknownConfiguration = true защищает от опечаток в ключах — неизвестное поле в конфиге вызовет ошибку, а не тихо проигнорируется. IOptionsMonitor против IOptionsSnapshot IOptionsMonitor<T> — синглтон. Одно и то же значение живёт на протяжении всего времени работы приложения и обновляется при изменении файла. IOptionsSnapshot<T> — скоупед. Значение фиксируется один раз на запрос и не меняется до его завершения. Это важно там, где нужна консистентность внутри одного HTTP-запроса — чтобы один и тот же запрос не увидел разные значения конфигурации в начале и в конце обработки. Если сервис живёт в синглтоне, используйте IOptionsMonitor. Если важна согласованность в рамках запроса, IOptionsSnapshot. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

⚙️ Покрытие кода для .NET Coverlet — инструмент для измерения покрытия кода в .NET-проектах. Он работает на Windows, macOS и Linux, поддерживает .NET Framework и .NET Core, и умеет считать покрытие по строкам, ветвям и методам. Без инструмента покрытия вы пишете тесты вслепую. Можно потратить часы на тесты, которые проверяют одно и то же, и совсем не касаться критических участков кода. Coverlet показывает точную картину: вот этот метод не вызывается ни одним тестом, а вот эта ветка if никогда не выполняется при тестировании. Как подключить Есть четыре варианта интеграции. Самый распространённый для современных проектов через VSTest. Он уже включён по умолчанию в шаблоны xUnit-проектов начиная с .NET 8. Если его нет, добавляем в тестовый проект:

dotnet add package coverlet.collector

Запускаем тесты с флагом сбора покрытия:

dotnet test --collect:"XPlat Code Coverage"

После выполнения в папке TestResults появится файл coverage.cobertura.xml с отчётом. Второй вариант через MSBuild:

dotnet add package coverlet.msbuild
dotnet test /p:CollectCoverage=true

Итог сразу появится в терминале, а файл coverage.json сохранится в корне тестового проекта. Третий вариант. Глобальный инструмент командной строки:

dotnet tool install --global coverlet.console
coverlet /path/to/test-assembly.dll --target "dotnet" --targetargs "test /path/to/test-project --no-build"

Четвёртый, самый новый, это интеграция с Microsoft Testing Platform. Подходит для проектов на Microsoft.Testing.Platform, требует .NET 8 и выше:

dotnet add package coverlet.MTP
dotnet test --coverlet

Если вы работаете в Visual Studio на Windows, расширение Fine Code Coverage умеет читать вывод Coverlet и подсвечивать покрытие прямо в редакторе. На macOS есть аналог VSMac-CodeCoverage. Coverlet не требует сложной настройки, встраивается в стандартный dotnet test, работает на всех платформах и бесплатен. ➡️ Репозиторий 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

✏️ Задание: не положить базу после истечения TTL Представьте: TTL кэша истёк, и сотни запросов одновременно обнаружили пустой кэш. Все ломятся в базу за одним и тем же значением. Это называется cache stampede. Как бы вы это решили? Какой примитив синхронизации выбрать, чтобы первый запрос шёл в БД, а остальные ждали его результата? Подумайте и проверьте свой ответ здесь: @csharp_interview_lib 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #dotnet_challenge

📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #garbage_collector

😱 Если ваш продукт не умеет отдавать данные в формате, понятном AI-агенту, то вас просто не существует Скрипт не будет кликать по красивым кнопкам в браузере, он уйдёт к конкуренту с нормальным API. Перестроить архитектуру под машинных клиентов — это уже не хайп, а необходимое условие сохранения конкурентоспособности. Как адаптировать продукт и не исчезнуть из выдачи: — интегрировать MCP и A2A-взаимодействие, чтобы агенты могли вас читать; — научиться контролировать стоимость (лимиты, кэш, роутинг между моделями); — настроить AgentOps: трейсинг, логирование и отлов регрессий. Всё это ждёт вас на обновлённом курсе «Разработка AI-агентов». Мы специально сделали фокус на утилитарном инжиниринге и production-ready решениях. Кстати, до 29 марта можно забрать курс с большой скидкой, и стоит поторопиться — мест на потоке всё меньше. Зафиксировать цену и начать деплоить агентов без слива бюджета 👈

🤔 Запросы в БД быстрые, кэш есть, async везде, но приложение тормозит Скорее всего виноват не код, а аллокации. Каждый раз, когда вы пишете Substring(), Split() или ToArray(), то вы создаёте новые объекты на хипе. При большой нагрузке это тысячи объектов в секунду. А дальше приходит Garbage Collector и делает паузу. Вот откуда те самые загадочные всплески задержек. Что делать: → Используйте Span<T> и ReadOnlySpan<T> вместо substring → ArrayPool<T>.Shared.Rent() вместо new массивов → StringBuilder пулить через ObjectPool → Профилируйте через dotnet-trace + BenchmarkDotNet Правило простое: меньше объектов на хипе → реже GC → стабильная латентность. Иногда пара изменений убирает 80% тормозов. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

🕸 Пять типичных ошибок при проектировании интеграции с помощью Kafka Система работала нормально, пока обработка батча не заняла слишком много времени. Координатор консьюмер-групп решил, что консьюмер мёртв, отверг коммит оффсета — и консьюмер начал читать сообщения заново. По кругу. Это называется ложная ребалансировка, и это один из самых неочевидных сценариев поломки. Архитектор Альфа-Банка разобрал пять таких историй из реального прода — с объяснением механики и тем, как этого избежать. ➡️ Читать статью 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта

⚙️ yield return не бесплатный Итераторы выглядят просто, но работают иначе:

IEnumerable<int> GetIds()
{
    foreach (var item in _items)
        yield return item.Id;
}

Читается как обычный цикл. Но компилятор превращает такой метод в конечный автомат со вспомогательными классами и состоянием. Именно поэтому итераторы такие выразительные — но и именно поэтому они не бесплатны. Где это становится проблемой На большинстве путей yield return это правильный выбор. Код чище, API удобнее, читаемость выше. Но на горячих путях, где метод вызывается тысячи раз в секунду, повторное создание объектов итератора и дополнительные слои абстракции начинают влиять на производительность. Не катастрофически, но измеримо. Что делать на критичных участках Если профилировщик показал, что итератор узкое место, есть несколько альтернатив. Заполнение буфера, переданного вызывающей стороной:

void FillIds(Span<int> buffer)
{
    for (int i = 0; i < _items.Count; i++)
        buffer[i] = _items[i].Id;
}

Возврат конкретной коллекции:

List<int> GetIds()
{
    var result = new List<int>(_items.Count);
    foreach (var item in _items)
        result.Add(item.Id);
    return result;
}

Прямой цикл внутри горячего кода без промежуточных перечислений:

for (int i = 0; i < _items.Count; i++)
    Process(_items[i].Id);

yield return стоит использовать тогда, когда он делает API лучше и код понятнее. Но не стоит считать его нулевым по стоимости. Если участок горячий, то сначала замерьте, потом решайте. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

🔎 Удалённое комбо вакансий для шарпистов Подобрали три вакансии для тех, кто не хочет выходить из дома: .NET-разработчик C#/.NET-разработчик Senior Backend .NET Engineer ➡️ Еще больше топовых вакансий — в нашем канале C# Jobs 🐸 Библиотека шарписта