Максимальная производительность C#: Span<T> и Memory<T>

string longText = GetSomeLongText();
string firstPart = longText.Substring(0, 100); // Создаётся новая копия в куче
string secondPart = longText.Substring(100, 100); // Ещё одна копия

unsafe void ProcessData(byte[] data)
{
    fixed (byte* ptr = data)
    {
        // Небезопасная, но эффективная работа с памятью
    }
}

// Традиционный подход в C# — множество аллокаций
var lines = File.ReadAllLines("huge.txt");
foreach (var line in lines)
{
    var parts = line.Split(',');
    // Каждый Split создаёт новый массив строк
}
 
// С использованием Span<T> можно избежать большинства аллокаций

byte[] array = new byte[100];
Span<byte> span = array; // Span, охватывающий весь массив
Span<byte> slice = array.AsSpan(10, 50); // Span, охватывающий часть массива

void ProcessData(Span<byte> data)
{
    // Один и тот же код работает с данными из разных источников
}
 
// Вызов с обычным массивом
byte[] array = new byte[1024];
ProcessData(array);
 
// Вызов с памятью на стеке
Span<byte> stackMemory = stackalloc byte[1024];
ProcessData(stackMemory);

// С обычным массивом:
byte[] originalArray = new byte[1000];
byte[] slice = new byte[100]; // Новый массив!
Array.Copy(originalArray, 50, slice, 0, 100); // Копирование данных
 
// Со Span<T>:
Span<byte> originalSpan = originalArray;
Span<byte> sliceSpan = originalSpan.Slice(50, 100); // Без копирования данных!

// Выделение памяти на стеке — очень быстрая операция, без участия GC
Span<int> stackInts = stackalloc int[100];

// Раньше приходилось делать так:
unsafe
{
    byte* ptr = (byte*)Marshal.AllocHGlobal(100).ToPointer();
    try
    {
        // Работа с указателем
    }
    finally
    {
        Marshal.FreeHGlobal(new IntPtr(ptr));
    }
}
 
// Теперь можно так:
byte[] managedArray = new byte[100];
Span<byte> span = managedArray;
// Работа со span как с обычным массивом, но без копирований

Span<int> numbers = new int[10000];
// Заполняем данными...
 
// Очень эффективная итерация с хорошим использованием кэша процессора
for (int i = 0; i < numbers.Length; i++)
{
    numbers[i] *= 2; // Прямой доступ к памяти без проверки границ в Release-сборке
}

// Это НЕ скомпилируется
class MyClass
{
    private Span<byte> _buffer; // Ошибка компиляции!
}
 
// И это тоже не сработает
async Task ProcessDataAsync(Span<byte> data) // Ошибка компиляции!
{
    await Task.Delay(100);
    // Работа с data
}

// Пример из .NET 5+
JsonSerializer.Deserialize<Person>(utf8JsonBytes.AsSpan());

unsafe
{
    int* stackArray = stackalloc int[100];
    // Работа с указателем
}

Span<int> stackNumbers = stackalloc int[100];
// Заполняем и используем как обычный массив, но без выделения в куче!

// Создание Span<T> из существующих массивов и строк
string text = "Hello, World!";
Span<char> chars = text.AsSpan();
 
// Конвертация обратно для использования со старыми API
byte[] buffer = new byte[100];
Span<byte> span = buffer;
Stream.Write(span.ToArray(), 0, span.Length); // Увы, здесь создаётся копия

// Современный подход без лишних аллокаций
Stream.Write(span); // Нет создания промежуточного массива

void ProcessFirstPart(Span<int> numbers)
{
    // Работа с первой половиной данных
}
 
void ProcessSecondPart(Span<int> numbers)
{
    // Работа со второй половиной данных
}
 
void ProcessAll(Span<int> allNumbers)
{
    int mid = allNumbers.Length / 2;
    ProcessFirstPart(allNumbers.Slice(0, mid));
    ProcessSecondPart(allNumbers.Slice(mid));
}

// Так НЕ сработает!
Span<byte> GetStackData()
{
    Span<byte> local = stackalloc byte[100];
    return local; // Ошибка компиляции!
}

// Это вполне допустимо
Span<byte> GetPartOfArray(byte[] array, int start, int length)
{
    return array.AsSpan(start, length);
}

// Memory<T> может быть полем класса
class BufferManager
{
    private Memory<byte> _buffer;
    
    public BufferManager(int size)
    {
        byte[] array = new byte[size];
        _buffer = array;
    }
    
    public Memory<byte> GetBuffer() => _buffer;
}

async Task ProcessDataAsync(Memory<byte> data)
{
    // Можно дождаться асинхронной операции
    await Task.Delay(100);
    
    // И после этого все ещё работать с данными
    for (int i = 0; i < data.Length; i++)
    {
        // Обработка данных
    }
}

async Task SendDataAsync(NetworkStream stream, Memory<byte> buffer)
{
    // Асинхронная запись в поток
    await stream.WriteAsync(buffer);
}
 
// Использование
byte[] data = GetSomeData();
await SendDataAsync(networkStream, data);

void ProcessMemory(Memory<int> memory)
{
    Span<int> span = memory.Span;
    
    // Теперь можно работать с данными через span
    for (int i = 0; i < span.Length; i++)
    {
        span[i] *= 2;
    }
}

async Task ProcessWithCachingAsync(Memory<byte> data)
{
    // Синхронная обработка через Span
    var span = data.Span;
    if (IsDataValid(span))
    {
        // Асинхронная запись результата
        await SaveResultAsync(data);
    }
}

async Task<int> ReadFromStreamAsync(Stream stream, Memory<byte> buffer)
{
    return await stream.ReadAsync(buffer);
}

void AnalyzeData(ReadOnlyMemory<byte> data)
{
    ReadOnlySpan<byte> span = data.Span;
    // Анализ данных без возможности их изменения
}

void ProcessWithNative(Memory<byte> data)
{
    Span<byte> span = data.Span;
    
    unsafe
    {
        fixed (byte* ptr = span)
        {
            // Вызов нативной функции с указателем
            NativeMethod(ptr, span.Length);
        }
    }
}

async Task ProcessLargeDataAsync()
{
    // Получение буфера из пула
    byte[] rentedArray = ArrayPool<byte>.Shared.Rent(16384);
    try
    {
        Memory<byte> buffer = rentedArray.AsMemory(0, 16384);
        await FillBufferAsync(buffer);
        await ProcessBufferAsync(buffer);
    }
    finally
    {
        // Возврат буфера в пул
        ArrayPool<byte>.Shared.Return(rentedArray);
    }
}

Memory<byte> CreateAndForget()
{
    var localArray = new byte[1000]; // Этот массив никто не сохраняет!
    return localArray; // Memory<T> ссылается на массив, который будет собран GC
}

class DataProcessor
{
    private byte[] _buffer; // Этот массив живёт столько же, сколько и класс
    private Memory<byte> _memory;
    
    public DataProcessor(int size)
    {
        _buffer = new byte[size];
        _memory = _buffer; // Memory ссылается на поле класса, всё безопасно
    }
    
    public Memory<byte> GetMemory() => _memory;
}

// Старый API с байтовыми массивами
void LegacyMethod(byte[] data, int offset, int count)
{
    // Какая-то обработка
}
 
// Современное использование
void ModernMethod(Memory<byte> memory)
{
    // Вариант 1: создание временного массива (есть аллокации)
    byte[] array = memory.ToArray();
    LegacyMethod(array, 0, array.Length);
    
    // Вариант 2: если источником был массив, можно его извлечь
    if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))
    {
        LegacyMethod(segment.Array, segment.Offset, segment.Count);
    }
}

public readonly ref struct Span<T>
{
    private readonly ref T _reference;  // managed pointer / managed reference
    private readonly int _length;
 
    // Методы и свойства...
}

public readonly struct Memory<T>
{
    private readonly object _object;  // Может быть массивом или другим объектом
    private readonly int _index;
    private readonly int _length;
    
    // Методы и свойства...
}

// Небезопасный вариант с указателями
unsafe void IncrementArrayUnsafe(int[] array)
{
    fixed (int* ptr = array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            ptr[i]++;
        }
    }
}
 
// Безопасный вариант со Span<T>
void IncrementArraySafe(Span<int> span)
{
    for (int i = 0; i < span.Length; i++)
    {
        span[i]++;
    }
}

void StackExample()
{
    Span<byte> spanOnStack; // Нормально, переменная на стеке
    
    // Такой код не скомпилируется:
    // object boxed = spanOnStack; // Нельзя сделать boxing Span<T>
    // сохранить в поле, передать в async-метод и т.д.
}

class BufferHolder
{
    public Memory<byte> Buffer { get; } // В куче, как часть объекта класса
    
    void MethodWithLocalMemory()
    {
        Memory<byte> localMemory; // На стеке, как локальная переменная
    }
}

void Example(Span<int> span)
{
    // Проверка границ здесь может быть удалена JIT-компилятором,
    // если он определит, что индекс никогда не выходит за пределы
    for (int i = 0; i < span.Length; i++)
    {
        span[i] *= 2;
    }
}

// Исходный код
void ProcessData(Span<int> data)
{
    for (int i = 0; i < data.Length; i++)
    {
        data[i] = data[i] * 2 + 1;
    }
}
 
// После JIT-оптимизаций (псевдокод)
void ProcessData_Optimized(ref int ptr, int length)
{
    // Единственная проверка границ
    if (length > 0)
    {
        // Возможно, векторизованный цикл для блоков по 4/8 элементов
        for (int i = 0; i < length; i++)
        {
            // Прямой доступ к памяти без дополнительных проверок
            *(ptr + i) = *(ptr + i) * 2 + 1;
        }
    }
}

static bool TryParseInt(ReadOnlySpan<char> input, out int result)
{
    result = 0;
    foreach (char c in input)
    {
        if (c < '0' || c > '9')
            return false;
            
        result = result * 10 + (c - '0');
    }
    return true;
}
 
// Использование без создания подстрок
string longText = "Важные числа: 123, 456, 789";
ReadOnlySpan<char> span = longText.AsSpan();
int startIndex = span.IndexOf(':') + 2;
int endIndex = span.IndexOf(',', startIndex);
int number;
 
if (TryParseInt(span.Slice(startIndex, endIndex - startIndex), out number))
{
    Console.WriteLine($"Распознанное число: {number}");
}

async Task ProcessFileAsync(string filePath)
{
    byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
    try
    {
        using var file = File.OpenRead(filePath);
        int bytesRead;
        Memory<byte> memory = buffer.AsMemory();
        
        while ((bytesRead = await file.ReadAsync(memory)) > 0)
        {
            // Работаем только с фактически прочитанными данными
            Memory<byte> data = memory.Slice(0, bytesRead);
            await ProcessDataChunkAsync(data);
        }
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

bool TryReadMessage(ref ReadOnlySpan<byte> buffer, out Message message)
{
    message = default;
    
    // Требуется минимум 8 байт для заголовка
    if (buffer.Length < 8)
        return false;
        
    // Чтение полей заголовка без копирования данных
    int messageType = BinaryPrimitives.ReadInt32LittleEndian(buffer);
    int payloadLength = BinaryPrimitives.ReadInt32LittleEndian(buffer.Slice(4));
    
    // Проверка, достаточно ли у нас данных для полного сообщения
    if (buffer.Length < 8 + payloadLength)
        return false;
    
    // Обработка полезной нагрузки
    var payload = buffer.Slice(8, payloadLength);
    message = new Message(messageType, payload.ToArray());
    
    // Продвигаем указатель чтения
    buffer = buffer.Slice(8 + payloadLength);
    return true;
}

async Task ProcessHttpRequestAsync(NetworkStream stream)
{
// Арендуем буфер из пула
byte[] rentedBuffer = ArrayPool<byte>.Shared.Rent(8192);
try
{
    Memory<byte> memory = rentedBuffer;
    int bytesRead = await stream.ReadAsync(memory);
    
    // Трактуем полученные данные как HTTP-запрос
    ReadOnlySpan<byte> requestData = memory.Span.Slice(0, bytesRead);
    
    // Ищем первую строку (запрос)
    int endOfFirstLine = requestData.IndexOf((byte)'\n');
    if (endOfFirstLine == -1) return;
    
    var requestLine = requestData.Slice(0, endOfFirstLine);
    // Разбираем метод, путь и версию без создания строк
    
    // Формируем ответ прямо в буфер
    var responseBuffer = memory.Slice(0, 1024);
    int written = CreateHttpResponse(responseBuffer.Span);
    
    // Отправляем ответ
    await stream.WriteAsync(responseBuffer.Slice(0, written));
}
finally
{
    ArrayPool<byte>.Shared.Return(rentedBuffer);
}
}

bool TryParseJson(ReadOnlySpan<char> json, out Person person)
{
person = null;
// Ищем начало объекта
int start = json.IndexOf('{');
if (start == -1) return false;
 
// Ищем поле "name"
int nameIndex = json.Slice(start).IndexOf("\"name\"");
if (nameIndex == -1) return false;
nameIndex += start + 7; // Смещение на "name": "
 
// Находим значение поля
int nameEndIndex = json.Slice(nameIndex).IndexOf('"');
if (nameEndIndex == -1) return false;
nameEndIndex += nameIndex;
 
// Получаем имя без создания подстроки
ReadOnlySpan<char> nameSpan = json.Slice(nameIndex, nameEndIndex - nameIndex);
 
// Аналогично для других полей...
 
// Создаём объект только один раз в конце парсинга
person = new Person(nameSpan.ToString());
return true;
}

bool TryFormat(Person person, Span<char> destination, out int charsWritten)
{
charsWritten = 0;
// Проверяем, достаточно ли места
int requiredLength = 2 + 9 + person.Name.Length + 3; // Для {name:"..."}
if (destination.Length < requiredLength)
    return false;
 
destination[charsWritten++] = '{';
// Записываем поле "name"
"\"name\":\"".AsSpan().CopyTo(destination.Slice(charsWritten));
charsWritten += 8;
person.Name.AsSpan().CopyTo(destination.Slice(charsWritten));
charsWritten += person.Name.Length;
destination[charsWritten++] = '"';
destination[charsWritten++] = '}';
 
return true;
}

static void FindAllOccurrences(ReadOnlySpan<char> text, ReadOnlySpan<char> pattern, 
                              Span<int> results, out int count)
{
    count = 0;
    int currentPos = 0;
    
    while (currentPos <= text.Length - pattern.Length)
    {
        int index = text.Slice(currentPos).IndexOf(pattern);
        if (index == -1)
            break;
            
        // Нашли совпадение, сохраняем позицию
        results[count++] = currentPos + index;
        currentPos += index + 1;
        
        // Проверка на переполнение буфера результатов
        if (count >= results.Length)
            break;
    }
}

async Task HandleRequestAsync(HttpContext context)
{
    // Получаем тело запроса как Memory<byte>
    var body = context.Request.BodyReader;
    var result = await body.ReadAsync();
    ReadOnlyMemory<byte> buffer = result.Buffer.First;
 
    // Предположим, что наш запрос содержит JSON
    if (TryParseRequest(buffer.Span, out var requestData))
    {
        // Обработка запроса
        var response = ProcessRequest(requestData);
        
        // Формирование ответа напрямую в буфер
        byte[] responseBuffer = ArrayPool<byte>.Shared.Rent(1024);
        try
        {
            int written = FormatResponse(response, responseBuffer);
            await context.Response.Body.WriteAsync(responseBuffer.AsMemory(0, written));
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(responseBuffer);
        }
    }
}

Span<byte> GetTemporarySpan()
{
    Span<byte> temp = stackalloc byte[128]; // Память в стеке
    // Заполняем данными...
    return temp; // ОШИБКА! Возврат ссылки на стековую память
}

void ProcessData(byte[] data)
{
    Func<Span<byte>> getSpan = () => {
        return data.AsSpan(0, 10); // Ошибка компиляции!
    };
}

async Task ProcessAsync(Span<byte> data) // Ошибка компиляции!
{
    await Task.Delay(100);
    // Обработка data
}

// Излишнее усложнение для простого случая
bool ContainsDigit(string text)
{
    ReadOnlySpan<char> span = text.AsSpan();
    foreach (char c in span)
    {
        if (char.IsDigit(c)) return true;
    }
    return false;
}
 
// Проще и понятнее для небольших строк
bool ContainsDigitSimple(string text)
{
    return text.Any(char.IsDigit);
}

// Работает в .NET 5+
int value = int.Parse("123".AsSpan());
 
// Для .NET Framework потребуется:
int value = int.Parse("123".AsSpan().ToString()); // Теряем все преимущества!

// Традиционный подход
public static int SumNumbersLegacy(string input)
{
    string[] parts = input.Split(',');
    int sum = 0;
    foreach (var part in parts)
    {
        if (int.TryParse(part, out int number))
            sum += number;
    }
    return sum;
}
 
// С использованием Span<T>
public static int SumNumbersSpan(ReadOnlySpan<char> input)
{
    int sum = 0;
    while (input.Length > 0)
    {
        int commaPos = input.IndexOf(',');
        ReadOnlySpan<char> part = commaPos == -1 ? input : input.Slice(0, commaPos);
        if (int.TryParse(part, out int number))
            sum += number;
            
        if (commaPos == -1) break;
        input = input.Slice(commaPos + 1);
    }
    return sum;
}

[Benchmark]
public int Legacy() => SumNumbersLegacy(testData);
 
[Benchmark]
public int SpanVersion() => SumNumbersSpan(testData);