Span<T> dan Memory<T> ialah jenis .NET moden untuk bekerja dengan memori bersebelahan (contiguous memory) (arrays, strings, buffers) dengan cekap — tanpa peruntukan atau penyalinan. Ia membolehkan kod berprestasi tinggi dengan menyediakan pandangan (view) ke dalam memori sedia ada berbanding mencipta salinan baru, mengurangkan tekanan GC.
// ❌ Substring allocates a NEW string (copies the data) — GC pressure in hot paths
string text = "Hello, World";
string sub = text.Substring(7); // allocates a new "World" string
// ✅ Span — a VIEW into the existing memory, NO allocation, NO copy
ReadOnlySpan<char> span = text.AsSpan(7); // "World" — points into the original
Operasi seperti Substring atau penghirisan array memperuntukkan objek baru dan menyalin data. Span<T> sebaliknya menyediakan pandangan (pointer + panjang) ke dalam memori sedia ada — penghirisan tidak berkos apa-apa, tidak memperuntukkan apa-apa.
int[] numbers = { 1, 2, 3, 4, 5 };
Span<int> slice = numbers.AsSpan(1, 3); // {2, 3, 4} — a VIEW, no copy
slice[0] = 99; // modifies the ORIGINAL array (it's a view)
// parse without allocating substrings
ReadOnlySpan<char> input = "123,456".AsSpan();
int first = int.Parse(input.Slice(0, 3)); // parse a slice, no substring allocation
Span<T> membolehkan anda menghiris dan memproses arrays/strings/buffers tanpa memperuntukkan — penting untuk hot paths (parsing, serialization, pemprosesan data besar).
Span<T> is a ref struct — it can ONLY live on the stack (not on the heap, not in
async methods, not as a class field). This guarantees safety but limits where it's used.
// Memory<T> is like Span<T> but CAN be a field / used across await (heap-storable)
async Task ProcessAsync(Memory<byte> buffer) // works in async (Span<T> can't)
{
await stream.ReadAsync(buffer);
Span<byte> span = buffer.Span; // get a Span from it when you need to process
}
Memory<T> melengkapkan Span<T> untuk senario di mana anda perlu menyimpan pandangan atau menggunakannya dalam kod async (di mana sifat hanya-stack Span<T> tidak berfungsi).
Span<T> dan Memory<T> ialah ciri .NET moden yang penting untuk kod berprestasi tinggi dan bebas-peruntukan, dan memahaminya ialah pengetahuan peringkat senior yang bernilai untuk aplikasi kritikal-prestasi.
Nilai terasnya ialah membolehkan kerja yang cekap dengan memori bersebelahan (arrays, strings, buffers) dengan menyediakan pandangan ke dalam memori sedia ada berbanding memperuntukkan salinan baru — yang penting kerana peruntukan mencipta tekanan GC, dan dalam hot paths (parsing, serialization, pemprosesan data besar, network buffers) mengelakkan peruntukan meningkatkan prestasi dengan ketara.
Operasi yang biasanya memperuntukkan (Substring, penghirisan array) boleh dilakukan secara bebas-peruntukan dengan spans, mengurangkan penggunaan memori dan overhead GC.
Memahami Span<T> (penghirisan tanpa-salinan arrays/strings/buffers), kekangan hanya-stacknya (ia adalah ref struct, jadi ia tidak boleh menjadi class field atau digunakan dalam async methods — had utama), dan Memory<T> (pelengkap yang boleh disimpan dan digunakan dalam kod async) adalah penting untuk menulis C# berprestasi tinggi.
Jenis-jenis ini digunakan secara meluas dalam kod kritikal-prestasi .NET moden sendiri dan semakin meningkat dalam libraries dan aplikasi di mana pengendalian memori yang cekap dan bebas-peruntukan penting.
Walaupun tidak diperlukan untuk logik perniagaan harian, memahami Span<T>/Memory<T> — apa yang ia lakukan (pandangan memori bebas-peruntukan), mengapa ia membantu (peruntukan dan tekanan GC yang dikurangkan), dan kekangannya — adalah bernilai untuk pembangunan C# yang sensitif prestasi (parsing, serialization, sistem throughput-tinggi), membezakan pembangun yang boleh menulis kod .NET yang sangat cekap, serta merupakan topik yang relevan untuk peranan senior yang berfokus prestasi.