Span<T> lan Memory<T> minangka tipe .NET modern kanggo kerja karo contiguous memory (arrays, strings, buffers) kanthi efisien — tanpa alokasi utawa copying. Padha ngaktifake high-performance code kanthi nyedhiyakake view menyang memory sing wis ana tinimbang nggawe copy anyar, nyuda GC pressure.
// ❌ 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 kaya Substring utawa array slicing nalokasi object anyar lan copy data. Span<T> malah nyedhiyakake view (pointer + length) menyang memory sing wis ana — slicing ora larang, ora nalokasi 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> ngidini slicing lan processing arrays/strings/buffers tanpa nalokasi — penting kanggo hot paths (parsing, serialization, processing data gedhé).
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> nambahi Span<T> kanggo skenario nang endi sampeyan butuh nyimpen view utawa nganggo ing async code (nang endi nature stack-only Span<T> ora bisa).
Span<T> lan Memory<T> minangka fitur .NET modern sing penting kanggo high-performance, allocation-free code, lan ngerti padha dadi pengetahuan senior-level sing bernilai kanggo aplikasi critical-performance.
Nilai inti padha yaiku ngaktifake kerja efisien karo contiguous memory (arrays, strings, buffers) kanthi nyedhiyakake view menyang memory sing wis ana tinimbang nalokasi copy anyar — bab iki penting amarga alokasi nyiptakake GC pressure, lan ing hot paths (parsing, serialization, processing data gedhé, network buffers) ngelak alokasi nambah performa kanthi signifikan.
Operasi sing biasane nalokasi (Substring, array slicing) bisa ditindakake tanpa alokasi karo spans, nyuda panggo memory lan GC overhead.
Ngerti Span<T> (zero-copy slicing saka arrays/strings/buffers), kendala stack-only (minangka ref struct, nang endi ora bisa dadi class field utawa dianggo ing async methods — limitasi kunci), lan Memory<T> (complement sing bisa disimpen lan dianggo ing async code) penting kanggo nulis high-performance C#.
Tipe-tipe iki dianggo kanthi akeh ing performance-critical code .NET dhewe lan saya luwih ing libraries lan applications nang endi allocation-free, efficient memory handling penting.
Meskipun ora dibutuhake kanggo business logic biasa-biasa, ngerti Span<T>/Memory<T> — apa sing padha lakoni (allocation-free memory views), kenapa padha nulungi (alokasi lan GC pressure sing berkurang), lan kendala padha — bernilai kanggo performance-sensitive C# development (parsing, serialization, high-throughput systems), membedakake developers sing bisa nulis .NET code sing highly efficient, lan minangka topik relevant kanggo performance-focused senior roles.
Pustaka pitakon wawancara IT kanthi jawaban rinci — saka Junior nganti Senior.
Nyumbang