# C# 14: хитрая задача на ArrayPool, IAsyncEnumerable и время жизни памяти

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

Наивная реализация:

static async IAsyncEnumerable<ReadOnlyMemory<byte>> ReadLinesAsync(
    Stream stream,
    [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);

    try
    {
        while (true)
        {
            int read = await stream.ReadAsync(buffer, cancellationToken);

            if (read == 0)
                yield break;

            yield return buffer.AsMemory(0, read);
        }
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

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

await foreach (var data in ReadLinesAsync(stream))
{
    queue.Add(data);
}

Код компилируется и выглядит эффективно.

Но в production данные внутри queue иногда внезапно меняются или повреждаются.

## Вопрос

Почему?

---

# Проблема

ReadOnlyMemory<byte> не владеет памятью.

Он всего лишь указывает на:

byte[] buffer

А этот массив взят из:

ArrayPool<byte>.Shared

После следующего:

ReadAsync(buffer)

содержимое массива перезаписывается.

А после:

ArrayPool<byte>.Shared.Return(buffer);

массив вообще может получить другой поток.

Получается:

yield memory
    ↓
consumer сохраняет ссылку
    ↓
buffer переиспользуется
    ↓
старый ReadOnlyMemory показывает новые данные

Это логический аналог use-after-free, хотя runtime C# остаётся memory-safe.

---

# Задача

Исправьте API так, чтобы:

- использовался пул памяти;
- данные можно было безопасно хранить после yield;
- не происходило скрытого копирования каждого сообщения;
- consumer явно управлял временем жизни буфера;
- отмена работала через CancellationToken.

Подсказка: используйте

IMemoryOwner<byte>

---

# Один из вариантов решения

public sealed class Message : IDisposable
{
    private IMemoryOwner<byte>? _owner;

    public ReadOnlyMemory<byte> Data { get; }

    public Message(IMemoryOwner<byte> owner, int length)
    {
        _owner = owner;
        Data = owner.Memory[..length];
    }

    public void Dispose()
    {
        _owner?.Dispose();
        _owner = null;
    }
}

Чтение:

static async IAsyncEnumerable<Message> ReadAsync(
    Stream stream,
    [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
    while (true)
    {
        IMemoryOwner<byte> owner =
            MemoryPool<byte>.Shared.Rent(4096);

        int read;

        try
        {
            read = await stream.ReadAsync(
                owner.Memory,
                cancellationToken);
        }
        catch
        {
            owner.Dispose();
            throw;
        }

        if (read == 0)
        {
            owner.Dispose();
            yield break;
        }

        yield return new Message(owner, read);
    }
}

Consumer:

await foreach (var message in ReadAsync(stream, ct))
{
    using (message)
    {
        Process(message.Data);
    }
}

Теперь память возвращается в pool только тогда, когда consumer закончил с сообщением.

---

# Главная ловушка

Даже такой код опасен:

ReadOnlyMemory<byte> saved;

await foreach (var message in ReadAsync(stream))
{
    using (message)
    {
        saved = message.Data;
    }
}

Console.WriteLine(saved.Length);

После Dispose() память больше не принадлежит consumer.

Сам ReadOnlyMemory<byte> технически существует, но использовать его содержимое уже нельзя.

---

# Вопрос уровня Senior

Как изменить API так, чтобы разработчику было сложнее случайно сохранить ReadOnlyMemory<byte> после Dispose()?

Дополнительно подумайте:

ArrayPool<T>
vs
MemoryPool<T>
vs
обычный byte[]

и ответьте, когда zero-copy действительно быстрее, а когда управление lifetime становится дороже простой копии.