Шпаргалка по throw и throw ex в C#!

Например, обычный throw внутри catch пробрасывает исходное исключение и сохраняет stack trace. А throw ex создаёт повторный выброс так, что место реальной ошибки становится сложнее найти.

На картинке показана разница между двумя вариантами. Есть сохранение stack trace, потеря исходного контекста, влияние на отладку и короткая таблица с правильным вариантом для catch-блоков.

Сохрани, чтобы не потерять!

➡️ C# Ready | #ресурс

Делаем потокобезопасный счётчик через Interlocked!

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

Обычный инкремент выглядит невинно:

_count++;

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

Для таких счётчиков в .NET есть Interlocked:

private int _count;

Interlocked.Increment(ref _count);

Теперь увеличение выполняется атомарно. Несколько потоков могут вызывать этот код одновременно, а итоговое значение не потеряет часть инкрементов.

Если нужно прибавить произвольное число, есть Add:

Interlocked.Add(ref _count, batchSize);

А для чтения текущего значения можно использовать CompareExchange без изменения:

int current = Interlocked.CompareExchange(ref _count, 0, 0);

Для long есть отдельные перегрузки, и это часто удобно для метрик, которые могут быстро расти:

private long _bytes;

Interlocked.Add(ref _bytes, size);

Interlocked подходит для простых числовых операций. Если нужно менять сразу несколько полей как одно состояние, лучше использовать lock или отдельную потокобезопасную структуру.

➡️ C# Ready | #практика

Напоминалка по async/await в C#!

Например, await приостанавливает выполнение метода до завершения Task, а Task.WhenAll() помогает дождаться нескольких независимых операций.
На картинке основные идеи async/await: зачем нужна асинхронность, что делают async и await, какие бывают return types, как запускать задачи параллельно и каких ошибок стоит избегать.

Сохрани, чтобы не потерять!

➡️ C# Ready | #ресурс

Парсим простой .env-файл на C#!

В небольших утилитах часто нужно прочитать настройки из файла вида KEY=value: токены, режим запуска, адрес API или путь к директории.

Пример строки:

var line = "APP_ENV=prod";

Разделим её по первому знаку =:

var index = line.IndexOf('=');

var key = line[..index];
var value = line[(index + 1)..];

Сохраним результат в словарь:

var config = new Dictionary<string, string>();
config[key] = value;

Теперь обработаем несколько строк:

foreach (var raw in File.ReadLines(".env"))
{
    var line = raw.Trim();

    if (line.Length == 0 || line.StartsWith("#"))
        continue;

    var index = line.IndexOf('=');

    if (index <= 0)
        continue;

    config[line[..index]] = line[(index + 1)..];
}

Пример .env:

APP_ENV=prod
PORT=8080
DEBUG=false

Использование:

Console.WriteLine(config["APP_ENV"]);
Console.WriteLine(config["PORT"]);

Ожидаемый вывод:

prod
8080

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

➡️ C# Ready | #практика

Шпаргалка по class, struct и record в C#!

Например, class передаётся по ссылке, struct хранит значение, record class даёт value equality для модели данных, а record struct совмещает value type с удобствами record.

На картинке сравниваются class, struct, record class и record struct. Есть тип хранения, значение по умолчанию, наследование, интерфейсы, immutability, equality, assignment и поведение ToString.

Сохрани, чтобы не потерять!

➡️ C# Ready | #ресурс

Ограничиваем параллельные запросы через SemaphoreSlim!

Иногда нужно обработать много элементов асинхронно, но не запускать всё сразу. Например, нельзя одновременно ударить сотнями запросов по API или базе.

Наивный вариант запускает все задачи сразу:

var tasks = urls.Select(DownloadAsync);
await Task.WhenAll(tasks);

Если urls много, приложение может упереться в лимиты сети, rate limit или пул соединений.

Для ограничения параллельности удобно использовать SemaphoreSlim:

var gate = new SemaphoreSlim(4);

Перед началом работы задача ждёт свободное место:

await gate.WaitAsync();

После завершения место обязательно освобождается через finally:

try
{
    await DownloadAsync(url);
}
finally
{
    gate.Release();
}

Теперь собираем задачи так, чтобы одновременно работало не больше четырёх:

var tasks = urls.Select(ProcessAsync);
await Task.WhenAll(tasks);

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

➡️ C# Ready | #практика

Полезная статья про тестирование ASP.NET Core API!

Автор показывает, как уменьшить повторение в интеграционных тестах и собрать удобное окружение с БД, фейковым временем и настройкой под конкретный тест.

В статье автор показывает:
• как устроить тестовое окружение для ASP.NET Core API
• почему setup-код быстро начинает повторяться
• как фикстуры помогают переиспользовать инфраструктуру

Продолжай читать на Habr

➡️ C# Ready | #статья

Собираем простой таймер в C#!

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

Создадим CancellationTokenSource:

using var cts = new CancellationTokenSource();

Теперь напишем отложенное действие:

static async Task RunLater(
    TimeSpan delay,
    Func<Task> action,
    CancellationToken token)
{
    await Task.Delay(delay, token);
    await action();
}

Запуск выглядит так:

var task = RunLater(
    TimeSpan.FromSeconds(3),
    () => SaveAsync(),
    cts.Token
);

Если пользователь изменил данные ещё раз, старую задачу можно отменить:

cts.Cancel();

Чтобы отмена не выглядела как ошибка, обработаем её отдельно:

try
{
    await task;
}
catch (OperationCanceledException)
{
    Console.WriteLine("Задача отменена");
}

Такой подход удобно использовать для debounce-сценариев: например, не сохранять форму после каждого символа, а ждать короткую паузу.

Пример с новым запуском:

cts.Cancel();

using var nextCts = new CancellationTokenSource();
await RunLater(
    TimeSpan.FromSeconds(1),
    () => SaveAsync(),
    nextCts.Token
);

В реальном приложении вместо SaveAsync может быть отправка запроса, пересчёт фильтра или обновление превью.

➡️ C# Ready | #практика