Span<T> da Memory<T> sune nau'i na zamani na .NET don aiki tare da alaƙar ƙarfe (arrays, strings, buffers) da kyau — ba tare da ƙarewa ko kwafi. Suna ba da damar samun aiki mai nauyi ta bada duba a cikin alaƙar da akwai a halin yanzu maimakon sabuwa nau'i, ta hanyar raguwa ga GC matsala.
// ❌ 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
Aikin kamar Substring ko sallama array suna ƙarewa nau'i sabon da kwafi data. Span<T> a maimakon yana ba da duba (nunka + tsawon) a cikin alaƙar da akwai — sallama ba ƙarfi, ba ƙarewa.
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> yana ba ku damar sallama da aiki arrays/strings/buffers ba tare da ƙarewa — mahimmanci ne don hanya mai zafi (parsing, serialization, aiki da babbar data).
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> yana bada taimako ga Span<T> don yanayin inda kuke buḥatar ajiye duba ko amfani da ita a async aiki (inda halayen stack-only na Span<T> ba aiki).
Span<T> da Memory<T> sune mahimman abubuwan zamani na .NET don aiki mai nauyi, ba ƙarewa, da fahimtar su yana da mahimmanci babbar ilimi don aikace-aikacen da ma'aja mahimmanci.
Dasukin gida ɓata ƙarfi sune bada damar aiki da alaƙar ƙarfe (arrays, strings, buffers) da kyau ta bada duba a cikin alaƙar da akwai maimakon ƙarewa kwafi sabuwa — wanda ya matukar mahimmanci saboda ƙarewa suna samar da GC matsala, da a hanya mai zafi (parsing, serialization, aiki da babbar data, network buffers) guje wa ƙarewa sosai yana inganta aiki.
Aikin da tsararrake suna ƙarewa (Substring, sallama array) ana iya aikatarwa ba ƙarewa tare da spans, raguwa ga amfani da alaƙa da GC matsala.
Fahimtar Span<T> (sallama ba ƙarfi na arrays/strings/buffers), takaitawarta stack-only (ita ita ref struct, to ba iya zama field ɗin ajiya ko amfani a async hanyoyi — takaitawa mahimmanci), da Memory<T> (nagari da zai iya zama ajiyewa da amfani a async aiki) yana mahimmanci don rubutu aiki mai nauyi C#.
Wannan nau'i ana amfani da su a ko'ina a aiki-mahimmanci na .NET kanta da karuwa a yalwajii da aikace-aikacen inda alaƙa ba ƙarewa, aiki mahimmanci.
Ko da yake ba a buƙata don yau da kullun aiki, fahimtar Span<T>/Memory<T> — me suke aikatarwa (duba alaƙa ba ƙarewa), me suke taimaka (raguwa ga ƙarewa da GC matsala), da takaitawansu — yana da mahimmanci don aiki mahimmaci C# (parsing, serialization, tsarin mai nauyi), bambanta masu aiki waɗa zai iya rubutu code mahimmaci .NET, da abuhu da ya danganta don mahimmaci-mayaro babbar aiki.