Span<T> u Memory<T> huma tipi moderni tal-.NET għat-tħaddim ma' memorja kontinwa (arrays, strings, buffers) b'effiċjenza — mingħajr allokazzjonijiet jew kopji. Huma jippermettu kodiċi ta' prestazzjoni għolja billi jipprovdu vista fi memorja eżistenti minflok joħolqu kopji ġodda, u b'hekk jnaqqsu l-pressjoni tal-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
Operazzjonijiet bħal Substring jew ħakk ta' array jallokaw oġġetti ġodda u jnisxu d-data. Span<T> minflok iforni vista (pointer + tul) fi memorja eżistenti — l-ħakk ma jissakrifika xejn, ma jallokax xejn.
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> jippermettilk taħħak u tipproċessa arrays/strings/buffers mingħajr allokazzjon — kruċjali għal passaġġi sħuħ (parsing, serializzazzjoni, ipproċessar ta' data kbira).
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> jikkumplimenta Span<T> għal senarios fejn ikollok bżonn taħżen il-vista jew tuża fiha fi kodiċi async (fejn in-natura stack-only ta' Span<T> ma taħdmx).
Span<T> u Memory<T> huma karatteristiċi moderni importanti tal-.NET għal kodiċi ta' prestazzjoni għolja, mingħajr allokazzjonijiet, u l-fahmija tagħhom hija għarfien valutabbli ta' livell senior għal applikazzjonijiet krittiċi għall-prestazzjoni.
Il-valur essenzjali tagħhom huwa li jippermettu ħidma effiċjenti mal-memorja kontinwa (arrays, strings, buffers) billi jipprovdu vista fi memorja eżistenti minflok jallokaw kopji ġodda — u dan ikun importanti għax l-allokazzjonijiet joħolqu pressjoni tal-GC, u fi passaġġi sħuħ (parsing, serializzazzjoni, ipproċessar ta' data kbira, network buffers) l-evitar tal-allokazzjonijiet itejbu sinifikantivament l-prestazzjoni.
Operazzjonijiet li normalment jallokaw (Substring, ħakk ta' array) jistgħu jsiru mingħajr allokazzjon bi spans, u b'hekk jittnaqqsu l-użu tal-memorja u l-overhead tal-GC.
Il-fahmija ta' Span<T> (ħakk mingħajr kopja ta' arrays/strings/buffers), il-limitazzjoni stack-only tagħha (huwa ref struct, allura ma jistax ikun field ta' class jew jintuża f'metodi async — limitazzjoni ewlenija), u Memory<T> (il-kumpliment li jista' jiġi maħżun u użat fi kodiċi async) hija importanti għall-kitba ta' C# ta' prestazzjoni għolja.
'Dħi tipi jintużaw b'abbundanza fil-kodiċi kritiku għall-prestazzjoni tal-.NET innu u dejjem aktar fi libreriji u applikazzjonijiet fejn l-immaniġġjar tal-memorja mingħajr allokazzjon u effiċjenti ikun importanti.
'Għalkemm mhux meħtieġ għal loġika tan-negozju ta' kuljum, il-fahmija ta' Span<T>/Memory<T> — x'jagħmlu (views tal-memorja mingħajr allokazzjon), għaliex jagħtu għonq (allokazzjonijiet u pressjoni tal-GC imnaqqsa), u l-limitazzjonijiet tagħhom — hija valuttabbli għall-iżvilupp ta' C# sensittiv għall-prestazzjoni (parsing, serializzazzjoni, sistemi ta' thrput għoli), li tiddistingwi l-iżviluppaturi li jistgħu jiktbu kodiċi .NET effiċjenti ħafna, u hija argument rilevanti għar-rwoli ta' senior fokusati fuq il-prestazzjoni.