Span<T> dan Memory<T> adalah tipe .NET modern untuk bekerja dengan memori yang bersambung (arrays, strings, buffers) secara efisien — tanpa alokasi atau penyalinan. Mereka memungkinkan kode berkinerja tinggi dengan menyediakan pandangan ke dalam memori yang sudah ada daripada membuat salinan baru, mengurangi 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 array slicing mengalokasikan objek baru dan menyalin data. Span<T> sebaliknya menyediakan pandangan (pointer + panjang) ke dalam memori yang sudah ada — slicing tidak mengeluarkan biaya, tidak mengalokasikan apapun.
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> memungkinkan Anda untuk melakukan slice dan memproses arrays/strings/buffers tanpa mengalokasikan — penting untuk hot paths (parsing, serialisasi, memproses 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> melengkapi Span<T> untuk skenario di mana Anda perlu menyimpan pandangan atau menggunakannya dalam kode async (di mana sifat stack-only dari Span<T> tidak berfungsi).
Span<T> dan Memory<T> adalah fitur .NET modern penting untuk kode berkinerja tinggi, tanpa alokasi, dan memahaminya adalah pengetahuan tingkat senior yang berharga untuk aplikasi yang performance-critical.
Nilai inti mereka adalah memungkinkan pekerjaan efisien dengan memori yang bersambung (arrays, strings, buffers) dengan menyediakan pandangan ke dalam memori yang sudah ada daripada mengalokasikan salinan baru — yang penting karena alokasi menciptakan tekanan GC, dan di hot paths (parsing, serialisasi, memproses data besar, buffer jaringan) menghindari alokasi secara signifikan meningkatkan performa.
Operasi yang biasanya mengalokasikan (Substring, array slicing) dapat dilakukan tanpa alokasi dengan spans, mengurangi penggunaan memori dan overhead GC.
Memahami Span<T> (slicing tanpa salinan dari arrays/strings/buffers), batasan stack-only-nya (ini adalah ref struct, jadi tidak bisa menjadi field kelas atau digunakan dalam metode async — batasan kunci), dan Memory<T> (pelengkap yang bisa disimpan dan digunakan dalam kode async) penting untuk menulis C# berkinerja tinggi.
Tipe-tipe ini digunakan secara luas dalam kode performance-critical .NET sendiri dan semakin banyak dalam library dan aplikasi di mana penanganan memori yang tanpa alokasi dan efisien penting.
Meskipun tidak diperlukan untuk logika bisnis sehari-hari, memahami Span<T>/Memory<T> — apa yang mereka lakukan (pandangan memori tanpa alokasi), mengapa mereka membantu (alokasi tereduksi dan tekanan GC yang lebih rendah), dan batasan mereka — berharga untuk pengembangan C# yang sensitif terhadap performa (parsing, serialisasi, sistem throughput tinggi), membedakan developer yang dapat menulis kode .NET yang sangat efisien, dan merupakan topik relevan untuk peran senior yang berfokus pada performa.