Оптимизация производительности: ValueTask

1. Введение

Прежде чем влетать в код, давайте разберёмся на пальцах. Помните, что простое создание объекта в .NET (а уж тем более — таска!) стоит памяти и немного времени процессора? Теперь представьте себе асинхронный API, который в половине случаев возвращает результат моментально (например, берёт его из кеша), а в другой половине — обращается к базе данных, поэтому операция становится действительно асинхронной и требует Task. Встречается часто — например, в файловых кэшах, сетевых API, пулах объектов и других "асинхронных, но иногда мгновенных" сценариях.

Если мы будем всегда возвращать Task, даже при мгновенных результатах нам придётся создавать лишние объекты. А что если бы мы могли возвращать результат без таска, если он уже готов? Вот для этого и родился ValueTask.

Факт: стандартные Task.CompletedTask и Task.FromResult(…) действительно экономят время на выполнение, но создают общий объект, который может быть неидеален для высоконагруженных сценариев.

Что такое ValueTask

ValueTask — это специальная структура-обёртка, которая может представлять либо уже готовый результат, либо (если операция реально асинхронна) сам таск. Проще говоря, это "пакет", который может содержать либо просто результат, либо ссылку на Task.

Есть две основные разновидности:

• ValueTask — "бессмысленный" (не возвращает значения, как Task)
• ValueTask<TResult> — обёртка для значения (аналог Task<TResult>)

Сравнение Task и ValueTask

Task

ValueTask

ValueTask<T>

Когда применять ValueTask

Есть золотое правило: если вы пишете обычный асинхронный метод, который всегда возвращает результат только после async-операции, используйте Task. Это просто, безопасно и понятно всем.

Использовать ValueTask стоит, когда:

• Результат может быть получен синхронно (например, из кэша, пула, памяти), и вы хотите сэкономить на лишних аллокациях.
• Асинхронная операция случается не слишком часто (иначе выгоды теряются на фоне усложнения кода и копирования структур).

Внимание! Если вы всегда возвращаете асинхронный результат — смело используйте Task. Если хотите, чтобы ваш API был "супер-оптимальным" для часто встречающихся мгновенных результатов — тогда ValueTask.

2. Синхронный или асинхронный результат

Рассмотрим функцию, которая ищет пользователя по имени. Если пользователь в кэше — возвращаем его мгновенно; если нет — асинхронно грузим из "базы":

// Моделируем нашего пользователя
public class User
{
    public string Name { get; set; }
}

// Наш cache (очень простой)
private readonly Dictionary<string, User> _localCache = new();

public async ValueTask<User> FindUserAsync(string name)
{
    // Проверяем локальный кэш
    if (_localCache.TryGetValue(name, out var user))
    {
        // Результат мгновенный — аллокаций таска нет!
        return user;
    }

    // Здесь якобы долгая асинхронная операция (например, из базы данных)
    user = await LoadUserFromDbAsync(name);
    // В кэш кладём на будущее
    _localCache[name] = user;
    return user;
}

private async Task<User> LoadUserFromDbAsync(string name)
{
    // Симулируем задержку
    await Task.Delay(500);
    return new User { Name = name };
}

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

Как устроен ValueTask внутри

У ValueTask внутри может лежать либо готовое значение, либо ссылка на Task:

ValueTask result = ValueTask.CompletedTask;
ValueTask<int> valueResult = new ValueTask<int>(42);
ValueTask<int> valueResult2 = new ValueTask<int>(Task.Run(() => 42));

При использовании await компилятор сам разберётся: если результат мгновенный, лишних объектов не создастся.

Важное про await и ValueTask

async-методы прекрасно дружат с await для ValueTask:

public async ValueTask PingAsync()
{
    // ...
    await Task.Delay(10);
}

Но если вы сохраняете экземпляр ValueTask и решаете дождаться его позже, помните: нельзя делать await одного и того же экземпляра более одного раза. Task можно ожидать многократно, а ValueTask — нет.

Ошибка: Повторный await ValueTask

ValueTask<int> task = ComputeAsync();

// Это ОК
int a = await task;

// Это ошибка! Второй await на том же экземпляре ValueTask не разрешён:
// int b = await task; // НЕЛЬЗЯ!

3. Перепишем часть нашего консольного приложения

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

private readonly Dictionary<string, string> _bookCache = new();

public async ValueTask<string> GetFirstLineOfBookAsync(string title)
{
    if (_bookCache.TryGetValue(title, out var bookText))
    {
        var firstLine = bookText.Split('\n')[0];
        return firstLine;
    }

    // Предположим, асинхронная загрузка книги
    var downloadedBook = await DownloadBookTextAsync(title);
    _bookCache[title] = downloadedBook;
    return downloadedBook.Split('\n')[0];
}

private async Task<string> DownloadBookTextAsync(string title)
{
    // Симулируем задержку (например, скачивание из интернета)
    await Task.Delay(1000);
    return $"Book: {title}\nThis is the first line.\nSecond line...";
}

Вот так ValueTask экономит создание таска, когда книга уже в кэше.

4. Полезные нюансы

Маркер: когда не надо использовать ValueTask

Если ваш API всегда асинхронный (например, всегда общение с сетью) — используйте Task, это проще и безопаснее.

Как превратить ValueTask в Task и наоборот

Бывает, что ValueTask "не помещается" в API, которому нужен Task. Используйте .AsTask():

ValueTask<int> valueTask = ComputeAsync();
Task<int> task = valueTask.AsTask();

Если нужно из Task сделать ValueTask — просто создайте ValueTask из таска:

Task<int> task = ComputeAsyncTask();
ValueTask<int> valueTask = new ValueTask<int>(task);

Сравнение: ValueTask vs Task

Task

ValueTask

Использование ValueTask в реальной жизни

public async ValueTask<string> GetMessageAsync(int id)
{
    if (_messageCache.TryGetValue(id, out var value))
        return value;

    var result = await LoadMessageFromDbAsync(id);
    _messageCache[id] = result;
    return result;
}

Применение на собеседовании: Если вас спрашивают, как ещё сильнее прокачать производительность асинхронного API с кэшированием, — скажите про ValueTask.

Примеры совместимости с LINQ и IAsyncEnumerable<T>

Если вы хотите использовать ValueTask с асинхронным LINQ (IAsyncEnumerable<T>), это поддерживается в .NET (например, метод ToListAsync):

public async ValueTask<List<int>> GetPrimeNumbersAsync()
{
    // Симулируем, что часть чисел уже вычислена, а часть — асинхронная операция
    // ... (пример опущен для краткости)
    return new List<int> { 2, 3, 5, 7, 11 };
}

5. Итоги и особенности реализации

1. Используйте ValueTask для оптимизации, когда значительную часть времени ваш результат готов мгновенно (например, из кэша).
2. Не используйте ValueTask "просто так" — это приведёт к усложнению кода и ошибкам.
3. Не await-ьте ValueTask несколько раз. Если нужно — преобразуйте его в Task.
4. Вся логика совместимости с Task — через .AsTask().
5. Помните, что ValueTask — struct, и может вести себя по-другому при копировании.

6. Типичные ошибки при работе с ValueTask

Ошибка №1: повторный await на одном экземпляре ValueTask. ValueTask — структура, её нельзя await-ить дважды. Второй await приведёт к исключению или некорректной работе.

Ошибка №2: использование ValueTask без явной проверки совместимости. Некоторые сторонние API требуют Task, и передача ValueTask напрямую может вызвать проблемы.

Ошибка №3: использование ValueTask без необходимости. Если результат всегда асинхронный, применение ValueTask усложняет код без реальной пользы.

Ошибка №4: копирование ValueTask как struct. Скопированная структура может вести себя неожиданно при await, важно работать с оригиналом.

2

Задача

C# SELF, 62 уровень, 2 лекция

Недоступна

Вернуть результат мгновенно или асинхронно

Вернуть результат мгновенно или асинхронно

Открыть