// ReadOnlySpan<char> — 문자열 일부를 새 할당 없이 참조
ReadOnlySpan<char> name  = "RefDock".AsSpan();
ReadOnlySpan<char> first = name[..3];  // "Ref" — 복사 없음

// 배열의 일부를 span으로
int[] arr   = { 1, 2, 3, 4, 5 };
Span<int> slice = arr.AsSpan(1, 3); // { 2, 3, 4 }
slice[0] = 99;                       // arr[1] == 99 — 원본 수정

// Span 기반 파싱 — Substring() 없이
ReadOnlySpan<char> line = "key=value".AsSpan();
int eq = line.IndexOf('=');
ReadOnlySpan<char> key   = line[..eq];       // "key"
ReadOnlySpan<char> value = line[(eq + 1)..]; // "value"

// Span<T>의 내부 구조 (개념)
// struct Span<T> { ref T _pointer; int _length; }
// 힙 포인터가 아닌 스택 포인터를 직접 들고 있음

// ❌ span을 클래스 필드로 보유 불가
class Bad { Span<int> _data; } // 컴파일 오류

// ❌ span을 await 경계로 넘길 수 없음
async Task ProcessAsync()
{
    Span<int> span = stackalloc int[10];
    await Task.Delay(1); // ❌ span은 await를 넘을 수 없음
}

// ✅ 동기 메서드에서만 사용
void Process(Span<int> span) { /* ... */ }

// ❌ span을 비동기 경계 밖으로 들고 나가려 함
ReadOnlySpan<char> part = line.AsSpan(0, 3);
// _pending = part; // 필드 저장 불가

// ✅ 비동기/보관이 필요하면 string 또는 Memory<T>로 전환
string part = line.Substring(0, 3);

// Memory<T>는 클래스 필드 가능
class Buffer
{
    private Memory<byte> _data = new byte[1024];

    public async Task ProcessAsync()
    {
        // Memory<T>는 await 경계를 넘을 수 있음
        await File.ReadAllBytesAsync("data.bin");

        // 동기 구간에서 Span으로 변환해 효율적으로 처리
        Span<byte> span = _data.Span;
        ParseBinary(span);
    }
}

// ❌ 기존 방식 — 매번 새 string 할당
string[] parts = line.Split(',');
for (int i = 0; i < parts.Length; i++)
    Process(parts[i]); // 각 부분이 새 string 객체

// ✅ span 방식 — 할당 없음
ReadOnlySpan<char> remaining = line.AsSpan();
while (!remaining.IsEmpty)
{
    int comma = remaining.IndexOf(',');
    ReadOnlySpan<char> part = comma >= 0 ? remaining[..comma] : remaining;
    ProcessSpan(part);
    remaining = comma >= 0 ? remaining[(comma + 1)..] : ReadOnlySpan<char>.Empty;
}

// 임시 버퍼 — 매번 새 배열 할당 → GC 부담
byte[] buffer = new byte[4096];
int read = stream.Read(buffer);

// ArrayPool — 반납 가능한 임시 배열
byte[] rented = ArrayPool<byte>.Shared.Rent(4096);
try
{
    int read = stream.Read(rented);
    Process(rented.AsSpan(0, read));
}
finally
{
    ArrayPool<byte>.Shared.Return(rented); // 풀에 반납
}