Интересный разбор того, как сегодня создавать игры на C# без готового движка!

В этой статье:
• Почему C# подходит для небольших кроссплатформенных игр
• Как SDL3 закрывает окна, ввод, контроллеры и рендеринг
• Как организовать загрузку ассетов и собрать собственный редактор на Dear ImGui

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

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

IT мероприятия 🤘

Всё самое интересное для карьеры в IT: митапы, хакатоны, конференции, стажировки и обучение.

Подписывайся 🤘

1. Москва
2. Санкт-Петербург
3. Для стажеров и студентов

CancellationToken должен проходить через всю цепочку вызовов!

Само наличие CancellationToken в параметрах ещё не делает операцию отменяемой:

async Task SyncAsync(CancellationToken token)
{
    var data = await LoadAsync();
    await SaveAsync(data);
}

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

Токен нужно передавать во все операции, которые поддерживают отмену:

var data = await LoadAsync(token);
await SaveAsync(data, token);
await Task.Delay(500, token);

Для вычислений без await запрос отмены необходимо проверять вручную:

foreach (var item in items)
{
    token.ThrowIfCancellationRequested();
    Process(item);
}

Отмена в .NET кооперативная: Cancel() не останавливает код принудительно. Он только сообщает операциям, что работу следует завершить.

Для собственного таймаута можно создать источник отмены:

using var timeout = new CancellationTokenSource(
    TimeSpan.FromSeconds(10)
);

await SyncAsync(timeout.Token);

Если одновременно нужен токен вызывающего кода и внутренний таймаут, их можно объединить:

using var linked = CancellationTokenSource
    .CreateLinkedTokenSource(token, timeout.Token);

await SyncAsync(linked.Token);

Передавайте CancellationToken до самого нижнего отменяемого вызова, иначе API обещает отмену, но фактическая работа продолжается.

➡️ C# Ready | #совет

Понятный разбор того, как на самом деле работает async/await в C#!

В этой статье:
• Чем асинхронность отличается от запуска работы в отдельном потоке
• Когда await освобождает поток, а когда выполнение продолжается синхронно
• Как компилятор превращает асинхронный метод в машину состояний

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

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

Почему yield return в C# выполняется не сразу?

Метод с yield выглядит как обычный метод:

IEnumerable<int> GetNumbers()
{
    Console.WriteLine("start");
    yield return 1;
    yield return 2;
}

Но при вызове код внутри ещё не выполняется:

var numbers = GetNumbers();

Console.WriteLine("created");

В консоли сначала будет:

created

А строка start появится только тогда, когда коллекцию начнут реально перебирать:

foreach (var number in numbers)
{
    Console.WriteLine(number);
}

И вот тогда выполнение пойдёт пошагово:

start
1
2

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

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

var users = LoadUsers();

DoSomething();

foreach (var user in users)
{
    Console.WriteLine(user.Name);
}

LoadUsers() может начать работу только на foreach, а не на первой строке.

Если нужно зафиксировать результат сразу, материализуй последовательность:

var users = LoadUsers().ToList();

yield return создаёт ленивую последовательность. Код внутри запускается при перечислении, а не при вызове метода.

➡️ C# Ready | #совет

Простая и популярная статья о создании Telegram-бота на C#!

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

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

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

Шпаргалка по недооценённым LINQ-методам в C#!

Например, SequenceEqual() помогает сравнить две последовательности по элементам, ToLookup() создаёт удобную группировку для быстрого доступа по ключу, а GroupJoin() полезен, когда нужно связать две коллекции и получить вложенный результат.

На картинке 5 LINQ-методов с короткими примерами кода: SequenceEqual, Aggregate, GroupJoin, ToLookup и Intersect.

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

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

Собираем простую очередь фоновых задач!

Иногда в приложении нужно отложить работу: отправить email, записать аудит, обработать файл или выполнить тяжёлую операцию после ответа пользователю.

Для этого можно собрать небольшую очередь на Channel<T>.

Сначала заведём интерфейс:

public interface ITaskQueue
{
    ValueTask EnqueueAsync(Func<CancellationToken, Task> job);
    IAsyncEnumerable<Func<CancellationToken, Task>> ReadAllAsync(
        CancellationToken token
    );
}

Реализация будет хранить задачи внутри Channel:

using System.Threading.Channels;

public sealed class TaskQueue : ITaskQueue
{
    private readonly Channel<Func<CancellationToken, Task>> _channel =
        Channel.CreateUnbounded<Func<CancellationToken, Task>>();

Добавление задачи:

    public ValueTask EnqueueAsync(Func<CancellationToken, Task> job)
    {
        return _channel.Writer.WriteAsync(job);
    }

Чтение задач:

    public IAsyncEnumerable<Func<CancellationToken, Task>> ReadAllAsync(
        CancellationToken token
    )
    {
        return _channel.Reader.ReadAllAsync(token);
    }
}

Теперь можно положить работу в очередь:

await queue.EnqueueAsync(async token =>
{
    await emailSender.SendAsync(user.Email, token);
});

А отдельный воркер будет выполнять задачи:

await foreach (var job in queue.ReadAllAsync(token))
{
    await job(token);
}

В ASP.NET Core такую логику обычно выносят в BackgroundService:

protected override async Task ExecuteAsync(CancellationToken token)
{
    await foreach (var job in queue.ReadAllAsync(token))
    {
        await job(token);
    }
}

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

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