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

🧑‍💻 HTTP Referer в ASP.NET Core Когда пользователь переходит по ссылке, браузер автоматически добавляет к запросу заголовок Referer — адрес страницы, с которой произошёл переход. Это стандартный механизм веба, и он уже встроен в HTTP. Никаких query string добавлять не нужно. Как читать Referer на сервере В ASP.NET Core заголовок доступен через Request.Headers:

app.MapGet("/page", (HttpContext ctx) =>
{
    var referer = ctx.Request.Headers["Referer"].ToString();

    if (string.IsNullOrEmpty(referer))
        return Results.Ok("Прямой переход или Referer скрыт");

    return Results.Ok($"Пришли с: {referer}");
});

В контроллерах то же самое:

[HttpGet]
public IActionResult Index()
{
    var referer = Request.Headers["Referer"].ToString();
    // использование по необходимости
    return View();
}

Как управлять тем, что браузер отправляет За это отвечает заголовок Referrer-Policy. Он задаётся на сервере и говорит браузеру, сколько информации об источнике передавать при переходах. Основные значения: no-referrer — браузер не отправляет Referer вообще. origin — передаёт только домен без пути: https://example.com/ вместо https://example.com/some/page. strict-origin-when-cross-origin — полный URL при переходах в рамках одного домена, только origin при переходах на другой домен, ничего при переходе с HTTPS на HTTP. unsafe-url — всегда передаёт полный URL, включая path и query. Название говорит само за себя. Настройка в ASP.NET Core Через middleware:

app.Use(async (ctx, next) =>
{
    ctx.Response.Headers["Referrer-Policy"] = "strict-origin-when-cross-origin";
    await next();
});

Или через app.UseHsts() в связке с пакетом NWebsec.AspNetCore.Middleware:

app.UseReferrerPolicy(opts => opts.StrictOriginWhenCrossOrigin());

Когда Referer может отсутствовать Браузер не отправляет заголовок в нескольких случаях: прямой ввод URL, переход из локального файла, политика no-referrer на стороне отправителя, переход с HTTPS на HTTP. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

🛠 C# для микроконтроллеров Написать прошивку для микроконтроллера на C — это нормально, но долго. Нужно управлять памятью вручную, разбираться с регистрами, держать в голове особенности конкретного железа. .NET nanoFramework меняет этот сценарий: код пишется на C#, отлаживается в Visual Studio, а запускается прямо на MCU. Что это такое .NET nanoFramework это открытая платформа для запуска C#-кода на микроконтроллерах с ограниченными ресурсами. Это не эмуляция и не кросс-компиляция в C. Прошивка nanoFramework устанавливается на устройство, и уже она выполняет скомпилированный C#-код. Как выглядит код Пример мигания светодиодом на ESP32:

using System.Device.Gpio;
using System.Threading;

var gpio = new GpioController();
gpio.OpenPin(2, PinMode.Output);

while (true)
{
    gpio.Write(2, PinValue.High);
    Thread.Sleep(500);
    gpio.Write(2, PinValue.Low);
    Thread.Sleep(500);
}

API намеренно выровнено с .NET IoT, поэтому код, написанный для Raspberry Pi через System.Device.Gpio, во многом переносится на MCU без серьёзных правок. Инструментарий Работа идёт в Visual Studio с бесплатным расширением nanoFramework. Поддерживается полноценный отладчик прямо на железе: точки останова, пошаговое выполнение, просмотр переменных. Пакеты распространяются через NuGet. Где применяется Среди реальных кейсов — мониторинг нефтяных скважин, удалённое управление солнечными электростанциями, промышленные измерительные системы. ➡️ Репозиторий 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

🤩 Copilot Studio перешёл на .NET 10 и стал быстрее Microsoft Copilot Studio обновил свой WebAssembly-движок с .NET 8 до .NET 10. Что изменилось Сам переход свёлся к обновлению <TargetFramework> на net10.0 и проверке совместимости зависимостей. Но за этим стоят три заметных улучшения в .NET 10 для WASM. Раньше WASM-приложениям приходилось вручную переименовывать файлы с добавлением SHA256-хеша для сброса кэша. Команда Copilot Studio использовала для этого отдельный PowerShell-скрипт, который читал манифест blazor.boot.json и прогонял каждый файл. В .NET 10 fingerprint встроен в имена файлов при публикации, а проверка целостности работает из коробки через dotnet.js. Скрипт удалили, аргумент integrity в загрузчике ресурсов убрали. Если вы загружаете .NET WASM-рантайм внутри WebWorker, при инициализации укажите dotnetSidecar = true. После AOT-компиляции методов в WebAssembly исходный IL-код больше не нужен в рантайме. В .NET 8 эта настройка существовала, но была выключена. Теперь IL автоматически вырезается из опубликованных сборок. Выигрыш в рантайме перекрывает рост размера пакета. Холодный запуск стал быстрее примерно на 20%. Повторные вызовы ускорились на ~5%. Больше всего выигрывают сложные агенты с большим объёмом AOT-кода. Как обновиться Обновите <TargetFramework> на net10.0 и подтяните свежие версии пакетов Microsoft.AspNetCore.*, Microsoft.Extensions.* и System.*. Если у вас были скрипты для переименования ресурсов или ручная проверка integrity, их можно удалить. Для автоматизации миграции Microsoft предлагает GitHub Copilot app modernization for .NET, который анализирует решение, планирует апгрейд и применяет изменения. ➡️ Блог разработчиков 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #async_news

📰 Второй майский дайджест Напоминаем, завтра выходной! — Кандидатов мало, а собесы становятся сложнее — Windows против других ИИ Google Chrome автоматически загружает локальную модель Gemini Nano весом 4 ГБ без согласия пользователя, а ручное удаление файла приводит к повторной закачке. Заблокировать это можно через реестр Windows 11. Майкрософт делают упор на ИИ: — Строим AI-агентов на .NET — AI-агенты в отказоустойчивом пайплайне на .NET 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #async_news

👨‍💻 Обработка исключений в AsParallel() Когда задачи выполняются параллельно и часть из них падает с ошибкой, .NET не бросает одно исключение. Вместо этого все ошибки собираются в AggregateException. Если не обработать его правильно, приложение просто упадёт, а вы потеряете детали о каждой конкретной ошибке. AggregateException содержит коллекцию InnerExceptions, где хранится каждое исключение из параллельного потока. Перебирая их в catch, мы получаем полный список того, что пошло не так, и можем реагировать на каждый случай отдельно. Вот как это выглядит:

try
{
    var results = items
        .AsParallel()
        .Select(item =>
        {
            if (item == null)
                throw new InvalidOperationException("Item is null");

            return ProcessItem(item);
        })
        .ToList();
}
catch (AggregateException ae)
{
    foreach (var ex in ae.InnerExceptions)
    {
        Console.WriteLine($"Handled: {ex.Message}");
    }
}

Если в items окажется null, код не упадёт молча. Каждая ошибка будет поймана и выведена отдельно. Используйте этот подход всегда, когда логика внутри AsParallel() может выбросить исключение. Это особенно актуально при работе с внешними данными, файлами или сетевыми вызовами, где ошибки непредсказуемы. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

🗓 14 мая в 19:00 (Мск) встречаемся в онлайне. Тема: Почему AI-продукты на базе LLM ломаются и как сделать, чтобы работало. В кружке выше Эмиль Сатаев рассказал, какие именно проблемы с LLM в проде будем разбирать. Что в программе:

- Разберем реальные кейсы стартапов и ограничения LLM. - Обсудим рабочие архитектуры: RAG, human-in-the-loop, контроль качества. - Ответим на ваши вопросы и разберем кейсы участников.

🎁 Бонусы: в конце вебинара подарим промокод на скидку 10.000 ₽ на курсы и разыграем подписки на полезные AI-сервисы. 👉 Зарегистрироваться на вебинар

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

🔥 Вопрос с собеса Представьте: продакшн .NET Core сервис под высокой нагрузкой. Задержки растут, потоки блокируются, DBA смотрит на вас с подозрением. БД вроде бы ни при чём.. или всё же при чём? Что вы будете делать? Если знаете — пишите в комментариях 👇 Если хотите проверить себя — ответ уже ждёт вас здесь 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #dotnet_challenge

📎 async void: почему это почти всегда плохая идея Методы async void в C# выглядят безобидно, но скрывают ловушку. Если внутри такого метода возникнет исключение, поймать его стандартными средствами не получится. Оно просто вылетит в поток синхронизации и, скорее всего, уронит приложение. Почему вообще существует async void? Всё просто: обработчики событий по соглашению возвращают void. Без поддержки async void нельзя было бы использовать async/await внутри них. Это единственный законный случай. Официальное правило звучит так: async void допустим только как обработчик события, и такой метод не должен бросать исключения. Правильный обработчик выглядит примерно так:

private async void Button_Click(object sender, EventArgs e)
{
    try
    {
        await DoSomethingAsync();
    }
    catch (Exception ex)
    {
        // обрабатываем ошибку здесь, не даём ей вылететь наружу
        MessageBox.Show(ex.Message);
    }
}

Всё остальное — async Task или async Task<T>. Это позволяет нормально ловить исключения, ждать завершения и тестировать метод. Если видите async void не в обработчике, это сигнал для ревью. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

🤩 Именованные поля в кортежах C# Иногда нужно вернуть из метода два-три значения или временно сгруппировать данные. Создавать для этого отдельный класс — лишняя работа. В C# 7+ есть кортежи с именованными полями, и они закрывают эту задачу. Как это выглядит Самый простой пример:

var user = (Name: "John", Age: 25);
Console.WriteLine(user.Name); // John
Console.WriteLine(user.Age);  // 25

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

public (string Name, bool IsValid) Validate(string input)
{
    var isValid = !string.IsNullOrWhiteSpace(input);
    return (input.Trim(), isValid);
}

var result = Validate("  John  ");
Console.WriteLine(result.Name);    // John
Console.WriteLine(result.IsValid); // True

Читаемость не хуже, чем у класса, а кода меньше. Деконструкция Кортеж можно сразу разложить по переменным:

var (name, isValid) = Validate("  John  ");
Console.WriteLine(name);    // John
Console.WriteLine(isValid); // True

Это удобно, если дальше в коде поля используются отдельно, а сам кортеж не нужен. Когда кортеж не подходит Кортежи хороши для локального использования и возвращаемых значений. Но если структура данных: - передаётся между слоями приложения - сериализуется в JSON или хранится в базе - используется более чем в двух-трёх местах Тогда лучше создать полноценный класс или record. Кортеж не несёт никакой доменной семантики — это просто набор значений. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

😎 AI-агенты в отказоустойчивом пайплайне на .NET Microsoft Agent Framework получил поддержку устойчивых воркфлоу. Теперь можно описать пайплайн из нескольких AI-агентов один раз и запустить его как в памяти процесса, так и на Azure Functions с автомасштабированием и отказоустойчивостью. Что было до этого Если в многошаговом пайплайне процесс падал или перезапускался, всё состояние терялось. Для долгоживущих задач это критично: агент может работать минуты или часы, и потерять прогресс на середине — дорого. Что делает MAF Workflows Фреймворк позволяет описать шаги как Executor<TInput, TOutput>, соединить их в граф через WorkflowBuilder и выбрать способ запуска, не меняя определение воркфлоу. Поддерживаются паттерны: - последовательные цепочки - параллельный fan-out / fan-in - условный роутинг (AddSwitch) - человек в петле (human-in-the-loop через RequestPort) - вложенные воркфлоу как sub-orchestrations Как это работает Описываем шаги:

internal sealed class OrderLookup()
    : Executor<OrderCancelRequest, Order>("OrderLookup")
{
    public override async ValueTask<Order> HandleAsync(
        OrderCancelRequest message,
        IWorkflowContext context,
        CancellationToken cancellationToken = default)
    {
        await Task.Delay(100, cancellationToken);
        return new Order(Id: message.OrderId, ...);
    }
}

Собираем граф:

Workflow cancelOrder = new WorkflowBuilder(orderLookup)
    .WithName("CancelOrder")
    .AddEdge(orderLookup, orderCancel)
    .AddEdge(orderCancel, sendEmail)
    .Build();

Запускаем в памяти (для локальной разработки):

await using StreamingRun run =
    await InProcessExecution.RunStreamingAsync(cancelOrder, input: cancelRequest);

await foreach (WorkflowEvent evt in run.WatchStreamAsync())
{
    if (evt is ExecutorCompletedEvent completed)
        Console.WriteLine($"{completed.ExecutorId}: {completed.Data}");
}

Добавляем устойчивость Для production подключаем Microsoft.Agents.AI.DurableTask. Определение воркфлоу остаётся прежним, меняется только хостинг:

dotnet add package Microsoft.Agents.AI.DurableTask --prerelease

Запускаем локальный эмулятор DTS:

docker run -d --name dts-emulator \
  -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

Дашборд доступен на http://localhost:8082. Там видно хронологию шагов, входные и выходные данные каждого executor'а. Регистрируем воркфлоу с durable runtime:

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.ConfigureDurableWorkflows(
            workflowOptions => workflowOptions.AddWorkflow(cancelOrder),
            workerBuilder: b => b.UseDurableTaskScheduler(dtsConnectionString),
            clientBuilder: b => b.UseDurableTaskScheduler(dtsConnectionString));
    })
    .Build();

Параллельные AI-агенты Агенты подключаются напрямую через AsAIAgent и запускаются параллельно. Если процесс упал в середине, завершённые агенты не перезапускаются:

AIAgent physicist = chatClient.AsAIAgent(
    "You are a physics expert. Be concise.", "Physicist");
AIAgent chemist = chatClient.AsAIAgent(
    "You are a chemistry expert. Be concise.", "Chemist");

Workflow workflow = new WorkflowBuilder(parseQuestion)
    .AddFanOutEdge(parseQuestion, [physicist, chemist])
    .AddFanInBarrierEdge([physicist, chemist], aggregator)
    .Build();

Одно определение воркфлоу работает везде: в памяти для разработки, с Durable Task для отказоустойчивости, на Azure Functions для serverless. Переключение между режимами не затрагивает код executor'ов. ➡️ Блог разработчиков 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

✏️ AsOrdered — когда порядок элементов важен в PLINQ AsParallel() обрабатывает данные параллельно и не гарантирует, что результат выйдет в том же порядке, что и входная последовательность. Если порядок важен, нужен AsOrdered(). Что делает AsOrdered Метод говорит PLINQ сохранять исходный порядок элементов в результирующей коллекции. Параллельная обработка при этом остаётся, но результат будет упорядочен так же, как входные данные. Зачем это нужно Есть случаи, когда порядок критичен — например, рендеринг элементов в UI или формирование отчёта, где строки должны идти в определённой последовательности. Без AsOrdered() результат непредсказуем. Пример использования:

var results = items
    .AsParallel()
    .AsOrdered()
    .Select(ProcessItem)
    .ToList();

PLINQ обработает элементы параллельно, но в results они окажутся в том же порядке, что и в items. Что учитывать AsOrdered() добавляет накладные расходы, ведь PLINQ вынужден отслеживать позиции элементов и собирать результат в нужном порядке. На больших объёмах данных это заметно. Поэтому используйте метод только там, где порядок действительно нужен, а не по умолчанию. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

😕 Подборка вакансий для шарпистов .NET Developer (Backend) Middle — до 6,000 $, удалёнка C#/.NET-разработчик — удалёнка Разработчик С# (User Interface, WPF) — от 120 000 ₽, офис в Перми ➡️ Еще больше топовых вакансий — в нашем канале C# Jobs 🐸 Библиотека шарписта

🎤 Ваши знания по ИИ-агентам + наша аудитория в 1 млн человек = профит Мы в Proglib активно качаем тему ИИ-агентов. Если вы в теме, то у нас есть предложение 👇 Что с нас? - Огромный охват: пропиарим ваши соцсети и продукты на 1 000 000+ айтишников. - Личный бренд: станете узнаваемым экспертом в самой горячей нише 2026 года. - Никакой рутины: наши редакторы сами упакуют ваши мысли в крутые посты. Что с вас? Любой экспертный контент по ИИ-агентам: кейсы из прода, шпаргалки, статьи, наработки по стеку (LangGraph, CrewAI, AutoGen и др.) или просто мысли по архитектуре. 👉 Стать экспертом и заявить о себе

👩‍💻 Когда ограничения мешают вставке Иногда при работе с PostgreSQL нужно вставить несколько связанных записей в одной транзакции, но внешние ключи проверяются сразу и транзакция падает. DEFERRABLE INITIALLY DEFERRED решает эту проблему — ограничение откладывается до конца транзакции. Что это и зачем По умолчанию PostgreSQL проверяет ограничения (FOREIGN KEY, UNIQUE, CHECK) сразу при выполнении каждого оператора. Если порядок вставки нарушает ссылочную целостность — получаем ошибку, даже если к концу транзакции всё было бы корректно. DEFERRABLE INITIALLY DEFERRED говорит базе: не проверяй ограничение после каждой операции — подожди до COMMIT. Это удобно, когда: - записи ссылаются друг на друга (циклические FK) - порядок вставки нельзя гарантировать - нужно пакетно импортировать данные без временного отключения ограничений Пример схемы Допустим, есть две таблицы, которые ссылаются друг на друга:

CREATE TABLE teams (
    id      SERIAL PRIMARY KEY,
    name    TEXT NOT NULL,
    lead_id INT REFERENCES employees(id) DEFERRABLE INITIALLY DEFERRED
);

CREATE TABLE employees (
    id      SERIAL PRIMARY KEY,
    name    TEXT NOT NULL,
    team_id INT REFERENCES teams(id) DEFERRABLE INITIALLY DEFERRED
);

Без DEFERRABLE INITIALLY DEFERRED вставить команду со ссылкой на сотрудника, которого ещё нет — невозможно. С ним — всё проверяется один раз при COMMIT. Как использовать в C# с Npgsql Npgsql поддерживает транзакции напрямую. Главное — убедиться, что обе вставки выполняются в одной транзакции.

await using var conn = new NpgsqlConnection(connectionString);
await conn.OpenAsync();

await using var tx = await conn.BeginTransactionAsync();

// Вставляем команду, но сотрудник ещё не существует
await using (var cmd = new NpgsqlCommand(
    "INSERT INTO teams (id, name, lead_id) VALUES (1, 'Backend', 42)", conn, tx))
{
    await cmd.ExecuteNonQueryAsync();
}

// Теперь вставляем сотрудника
await using (var cmd = new NpgsqlCommand(
    "INSERT INTO employees (id, name, team_id) VALUES (42, 'Иван', 1)", conn, tx))
{
    await cmd.ExecuteNonQueryAsync();
}

// FK проверяются здесь — оба существуют, всё ок
await tx.CommitAsync();

Без DEFERRABLE INITIALLY DEFERRED первая вставка упала бы с ошибкой foreign key violation, потому что employees(42) не существует в момент вставки команды. Как использовать с EF Core EF Core сам по себе не умеет объявлять DEFERRABLE ограничения через Fluent API. Но можно сделать через HasCheckConstraint с raw SQL или через миграцию. Самый надёжный способ — написать миграцию вручную:

protected override void Up(MigrationBuilder migrationBuilder)
{
    migrationBuilder.Sql(@"
        ALTER TABLE teams
        DROP CONSTRAINT IF EXISTS teams_lead_id_fkey;

        ALTER TABLE teams
        ADD CONSTRAINT teams_lead_id_fkey
        FOREIGN KEY (lead_id) REFERENCES employees(id)
        DEFERRABLE INITIALLY DEFERRED;
    ");
}

После этого транзакции EF Core будут пользоваться отложенной проверкой автоматически — ничего дополнительно настраивать не нужно. Разница между DEFERRED и IMMEDIATE DEFERRABLE означает, что ограничение можно отложить. INITIALLY DEFERRED — что оно отложено по умолчанию для каждой транзакции. Если нужно временно изменить поведение внутри конкретной транзакции — можно явно переключить режим:

-- Внутри транзакции включить немедленную проверку
SET CONSTRAINTS teams_lead_id_fkey IMMEDIATE;

-- Или отложить конкретное ограничение
SET CONSTRAINTS teams_lead_id_fkey DEFERRED;

В C# через Npgsql это выполняется как обычный SQL-запрос внутри транзакции:

await using var cmd = new NpgsqlCommand(
    "SET CONSTRAINTS ALL DEFERRED", conn, tx);
await cmd.ExecuteNonQueryAsync();

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

⭐️ Когда отмена не нужна, но сигнатура требует токен Многие методы в .NET принимают CancellationToken как параметр. Это правильная практика: метод должен уметь реагировать на отмену. Но что делать, если в конкретном месте отмена просто не нужна? Что такое CancellationToken.None CancellationToken.None — это пустой токен. Его свойство CanBeCanceled всегда возвращает false. Отменить его невозможно, и никакие CancellationTokenSource к нему не привязаны. Используется там, где токен нужно передать по сигнатуре, но реальной логики отмены нет:

await DoWorkAsync(CancellationToken.None);

Альтернатива через default В C# есть эквивалентный способ:

await DoWorkAsync(default);
// или явно
await DoWorkAsync(default(CancellationToken));

default(CancellationToken) и CancellationToken.None равны между собой. Два пустых токена всегда равны, вне зависимости от того, как они созданы. Когда применять Типичный сценарий: вызов метода в Main, в тестах или в коде инициализации, где нет смысла настраивать отмену, но метод её принимает.

// Тест без отмены
var result = await repository.GetAllAsync(CancellationToken.None);

// Инициализация при старте приложения
await migrationService.RunAsync(CancellationToken.None);

Что не стоит делать Передавать new CancellationToken() вместо CancellationToken.None. Технически результат тот же, но это создаёт ложное ощущение, что токен где-то настроен. CancellationToken.None читается однозначно: отмены здесь нет намеренно. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view

⭐️ WithDegreeOfParallelism: как управлять параллелизмом в PLINQ По умолчанию PLINQ сам решает, сколько потоков использовать, опираясь на количество ядер процессора. Это удобно, но не всегда подходит. Что делает WithDegreeOfParallelism Метод позволяет вручную задать максимальное число потоков, которые PLINQ будет использовать при обработке данных. Это прямой контроль над тем, сколько ресурсов займёт параллельная операция. Зачем это нужно Если задачи тяжёлые по CPU, без ограничений PLINQ может «съесть» все ядра. Остальные части приложения начнут тормозить — особенно заметно в десктопных приложениях, где есть UI-поток. Пример использования:

var results = items
    .AsParallel()
    .WithDegreeOfParallelism(4)
    .Select(ProcessItem)
    .ToList();

Здесь мы явно говорим PLINQ использовать не больше 4 потоков, независимо от того, сколько ядер на машине. Когда применять Метод полезен в двух ситуациях: 1. Обработка больших файлов или тяжёлых вычислений, когда нужно оставить ресурсы для UI или других процессов. 2. Когда пул потоков по умолчанию перегружен и это влияет на другие операции в приложении. Устанавливайте значение исходя из реальной нагрузки. Четыре потока это не универсальный ответ, это отправная точка для тестирования. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #il_люминатор

📎 Не проверяйте задачи в цикле Когда задача уже запущена и нам остаётся только ждать её завершения, некоторые пишут примерно такой код:

while (!task.IsCompleted)
{
    Thread.Sleep(100);
}

Выглядит логично, но на практике это сводит на нет весь смысл асинхронности. Что происходит под капотом Поток не освобождается. Он занят проверкой статуса в цикле и не делает ничего полезного. Процессор тратит такты на холостые итерации, хотя эти ресурсы могли бы использоваться другим кодом, в том числе самой ожидаемой операцией. Это особенно критично в серверных приложениях, где количество потоков ограничено. Заблокированный поток в пуле означает, что следующий запрос будет ждать. Используйте await:

await task;

Это освобождает поток до завершения задачи. Планировщик вернёт управление в нужный момент без лишних проверок и потраченных ресурсов. 📍 Навигация: Вакансии • Задачи • Собесы 🐸 Библиотека шарписта #sharp_view