⚙️ Под капотом async/await

Когда вы пишете асинхронный метод вроде:

async Task<int> GetDataAsync()
{
    var data = await FetchAsync();
    return data.Length;
}

вы можете думать, что это «всего лишь ожидание задачи». Но на самом деле компилятор C# превращает этот метод в state machine — конечный автомат, который управляет переходами между состояниями выполнения.

State machine — это структура, которая:

• хранит текущее состояние выполнения программы, например, до await, после await или завершено,

• знает, в какое состояние перейти дальше, когда наступает внешнее событие например, завершение Task.

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

Что делает компилятор

При компиляции метода с await создаётся вспомогательный класс, реализующий интерфейс IAsyncStateMachine.

Если упростить, то наш пример превращается примерно в:

private struct GetDataAsyncStateMachine : IAsyncStateMachine
{
    public int _state;
    public AsyncTaskMethodBuilder<int> _builder;
    private TaskAwaiter<string> _awaiter;

    public void MoveNext()
    {
        try
        {
            if (_state == 0)
            {
                // после await
                var result = _awaiter.GetResult();
                _builder.SetResult(result.Length);
                return;
            }

            var task = FetchAsync();
            if (!task.IsCompleted)
            {
                _state = 0;
                _awaiter = task.GetAwaiter();
                _builder.AwaitUnsafeOnCompleted(ref _awaiter, ref this);
                return;
            }

            _builder.SetResult(task.Result.Length);
        }
        catch (Exception ex)
        {
            _builder.SetException(ex);
        }
    }

    public void SetStateMachine(IAsyncStateMachine stateMachine) { }
}

Другие примеры использования state machines в C#

• yield return — генерация итераторов IEnumerator

• foreach на async коллекциях — асинхронные итераторы IAsyncEnumerable

Каждый await или yield превращает метод в "автомат", который сам управляет своим ходом выполнения.

🐸 Библиотека шарписта

#il_люминатор

🛠 Ловите ошибку сразу

Ничто не портит день разработчика так, как внезапный NullReferenceException в проде.
Лучше упасть сразу — с понятным сообщением, чем потом искать, где всё пошло не так.

Как избежать ошибки:

_ = arg ?? throw new ArgumentNullException(nameof(arg));

Это fail-fast подход: программа ломается там, где ошибка реально возникла, а не через пять вызовов.
Полезно для входных параметров, обязательных зависимостей и DTO, пришедших из вне.

🐸 Библиотека шарписта

#sharp_view

⭐️ Два пункта вниз

C# потерял сразу две позиции в рейтинге PYPL. Его доля снизилась примерно на -2.5 % поисковых запросов.

🐸 Библиотека шарписта

#async_news

🎓 Как вайб-кодинг меняет рынок IT-образования

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

Этот сдвиг называют «вайб-кодингом». Он уже влияет на университетские программы, онлайн-курсы и требования к выпускникам.

➡️ В статье о том, что стоит за этим термином и как он меняет обучение IT-специалистов.

🐸 Библиотека шарписта

👀 Баг или фича

Пока мы думали как бы вам рассказать про наш Х, обнаружили любопытную вещь: если пользователь не залогинен в Х, то лента нашего паблика пустая — ни одного поста.

Теперь разбираемся, это недоработка или новая фича, мотивирующая авторизацию 🙂

🐸 Библиотека шарписта

🐸 Библиотека шарписта

#garbage_collector

⌛️ Таймаут в одну строку

Когда нужно ограничить время ожидания ответа от HTTP-запроса можно использовать метод WaitAsync для установки таймаута без необходимости создавать отдельные токены отмены.

Пример:

var response = await http.GetAsync(url).WaitAsync(TimeSpan.FromSeconds(5));

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

🐸 Библиотека шарписта

#sharp_view

😂 Почему Console.ReadLine() не работает в браузере

Вы когда-нибудь пытались использовать метод Console.ReadLine() в онлайн-компиляторе C#? Да, звучит как извращение, но давайте углубимся в проблему.

Метод Console.ReadLine() позволяет вашему приложению ожидать ввода пользователя в консоли — это основной инструмент для взаимодействия с пользователем в командной строке.

Но когда вы пытаетесь использовать этот метод в браузерной среде, появляется проблема: браузеры просто не поддерживают работу с консолью напрямую. Атрибут [System.Runtime.Versioning.UnsupportedOSPlatform("browser")] прямо в документации говорит: «Не поддерживайте это в браузере!»

Браузер — это отличное место для быстрых экспериментов, но когда речь идет о полноценной разработке, лучше использовать локальные инструменты: Visual Studio или Visual Studio Code.

🐸 Библиотека шарписта

#sharp_view

👀 Показываем взаимодействие окружений в Git

🐸 Библиотека шарписта

#схема

🚀 JetBrains .NET Days 2025

JetBrains снова собрала лучших инженеров и евангелистов .NET на своей онлайн-конференции .NET Days. Два дня плотных докладов — от чистой архитектуры и распределённых систем до GenAI и F#.

1️⃣ Самое интересное за первый день:

• Чистая архитектура с ASP.NET Core

Как выстроить проект так, чтобы код был читаемым, тестируемым и легко рефакторился. Разделение слоёв и зависимостей без боли.

• Nullability в C#: включаем защиту от NullReferenceException

Аннотации и статический анализ помогают избавиться от NullReferenceException и внедрить null safety даже в старый код.

• Как выбрать систему обмена сообщениями

Сравнение AWS SQS, RabbitMQ и Azure Service Bus — плюсы, минусы и типичные ошибки при выборе очередей сообщений.

• TDD на фронтенде с Blazor

Как применять TDD на фронтенде с Blazor и bUnit. Быстрая обратная связь и уверенность в каждом изменении.

2️⃣ Темы за второй день:

• Версионирование событийных систем

Безопасные приёмы эволюции событий: версионирование, апкастинг и совместимость без поломок у потребителей.

• Генеративный ИИ и .NET Aspire в действии

Интеграция LLM, управление контекстом и масштабируемая оркестрация с помощью Semantic Kernel и Aspire.

• Функциональное программирование в F#: мода или польза

Реальные преимущества функционального подхода — лаконичные пайплайны, паттерн-матчинг и безопасные абстракции.

• Как нашли утечку 2 ГБ в день за 5 минут

История о том, как обнаружить гигабайтные утечки памяти с помощью dotMemory в продакшене за считанные минуты.

Два дня — и десятки инсайтов о будущем .NET: от облаков и AI до функционального подхода и устойчивой архитектуры. Записи доступны на YouTube.

➡️ Первый день
➡️ Второй день

🐸 Библиотека шарписта

#il_люминатор

✏️ Задача с собеса: квадраты отсортированного массива

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

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

1. Обрабатываем два края массива (left и right), сравниваем их квадраты.

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

3. Сдвигаем соответствующий указатель — либо left, либо right.

4. В конце получаем отсортированный массив квадратов.

Решение с двумя указателями:

public int[] SortedSquares(int[] nums) {
    int n = nums.Length;
    int[] result = new int[n];
    int left = 0, right = n - 1, pos = n - 1;

    while (left <= right) {
        int leftSq = nums[left] * nums[left];
        int rightSq = nums[right] * nums[right];

        if (leftSq > rightSq) {
            result[pos] = leftSq;
            left++;
        } else {
            result[pos] = rightSq;
            right--;
        }
        pos--;
    }
    return result;
}

➡️ Попробовать на литкоде

🐸 Библиотека шарписта

#dotnet_challenge

🐸 Библиотека шарписта

#garbage_collector

🧠 Должен ли разработчик запоминать код

На Reddit вспыхнула классическая тема — запоминают ли профессиональные разработчики свой код.

Комментаторы разбились на два лагеря:

Если ты не помнишь, как работает твоя функция, ты просто копипастер!

и

Профессионал не держит в голове код, он держит в голове логику и подход. Код — деталь реализации

💬 Нужно ли запоминать код, или важно просто понимать, как он работает?

🐸 Библиотека шарписта

#entry_point

📰 Дайджест недели

Что произошло в мире за последние семь дней.

— Разработчик как AI-код-ревьюер

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

— .NET 10 готовит революцию в управлении памятью

Разработчики включат по умолчанию функцию DATAS, которая адаптирует размер кучи к текущим потребностям приложения.

— C# потерял две позиции в рейтинге PYPL

— Как вайб-кодинг меняет рынок IT-образования

— JetBrains .NET Days 2025

🐸 Библиотека шарписта

#async_news

🐸 Библиотека шарписта

#garbage_collector

🚩 Задача с собеса

Задача: дана строка s и строка p. Необходимо найти все начальные индексы подстрок в s, которые являются анаграммами строки p.

Анаграмма — это слово или фраза, образованная перестановкой букв другого слова, используя все исходные буквы ровно один раз.

Пример:

Input: s = "cbaebabacd", p = "abc"
Output: [0, 6]

Объяснение:
Подстрока с индекса 0 - "cba", анаграмма "abc".
Подстрока с индекса 6 - "bac", анаграмма "abc".

Оптимальное решение использует технику скользящего окна с подсчетом частот символов.

1. Подсчитываем количество и частоту всех символов в строке p
2. Создаем скользящее окно размером со строку p в строке s
3. Для каждой позиции окна сравниваем частоты символов с эталоном
4. При совпадении добавляем индекс в результат

Код:

public class Solution 
{
    public IList<int> FindAnagrams(string s, string p) 
    {
        List<int> result = new List<int>();
        
        if (s.Length < p.Length) 
            return result;
        
        // Массивы для подсчета частот символов (26 букв английского алфавита)
        int[] pCount = new int[26];
        int[] windowCount = new int[26];
        
        // Подсчитываем частоты в строке p и первом окне
        for (int i = 0; i < p.Length; i++) 
        {
            pCount[p[i] - 'a']++;
            windowCount[s[i] - 'a']++;
        }
        
        // Проверяем первое окно
        if (AreEqual(pCount, windowCount))
            result.Add(0);
        
        // Скользим окном по строке s
        for (int i = p.Length; i < s.Length; i++) 
        {
            // Добавляем новый символ справа
            windowCount[s[i] - 'a']++;
            
            // Удаляем старый символ слева
            windowCount[s[i - p.Length] - 'a']--;
            
            // Проверяем текущее окно
            if (AreEqual(pCount, windowCount))
                result.Add(i - p.Length + 1);
        }
        
        return result;
    }
    
    // Вспомогательный метод для сравнения массивов частот
    private bool AreEqual(int[] arr1, int[] arr2) 
    {
        for (int i = 0; i < 26; i++) 
        {
            if (arr1[i] != arr2[i])
                return false;
        }
        return true;
    }
}

🐸 Библиотека шарписта

#dotnet_challenge

🔍 Как работать с массивами в C# без тормозов и без unsafe-кода

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

Есть третий путь — Span<T>

Span — это структура, которая хранит указатель на данные и их длину. Фишка в том, что это ref struct — она живёт только в стеке и не может попасть в кучу. Благодаря этому компилятор гарантирует: данные переживут span, а значит проверки границ можно убрать.

Например, в быстрой сортровке вместо передачи массива с индексами low/high передаёте span. Код короче, переполнение невозможно, а рекурсивные вызовы работают через срезы:

// Было: опасно, (low + high) может переполниться
void Quicksort(int[] array, int low, int high) {
    int mid = (low + high) / 2;  // 💥 overflow!
    // ...
    Quicksort(array, low, pivot - 1);
    Quicksort(array, pivot + 1, high);
}

// Стало: безопасно и выразительно
void Quicksort(Span<int> span) {
    if (span.Length <= 1) return;
    
    int pivot = Partition(span);
    Quicksort(span[..pivot]);        // левая часть
    Quicksort(span[(pivot + 1)..]);  // правая часть
}

Раньше для передачи части массива в функцию приходилось либо копировать данные, либо таскать массив + offset + length. Span решает это элегантно: создаёте срез array[10..20], передаёте дальше — никакого копирования, полная безопасность типов.

🐸 Библиотека шарписта

#il_люминатор