Span<T> na Memory<T> ni aina za kisasa za .NET za kufanya kazi na kumbukumbu inayofuatana (contiguous memory) (arrays, strings, buffers) kwa ufanisi — bila allocations au kunakili. Zinawezesha msimbo wa utendaji wa juu kwa kutoa mtazamo (view) ndani ya kumbukumbu iliyopo badala ya kuunda nakala mpya, zikipunguza shinikizo la 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
Operations kama Substring au array slicing huweka objects mpya na kunakili data. Span<T> badala yake hutoa view (pointer + length) ndani ya kumbukumbu iliyopo — slicing haina gharama, haiweki allocation yoyote.
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> inakuwezesha kukata na kuchakata arrays/strings/buffers bila allocation — muhimu kwa hot paths (parsing, serialization, kuchakata data kubwa).
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> hukamilisha Span<T> kwa hali ambapo unahitaji kuhifadhi view au kuitumia katika async code (ambapo asili ya stack-only ya Span<T> haifanyi kazi).
Span<T> na Memory<T> ni vipengele muhimu vya kisasa vya .NET kwa msimbo wa utendaji wa juu, usio na allocation, na kuvielewa ni ujuzi wa thamani wa kiwango cha senior kwa programu nyeti za utendaji.
Thamani yao ya msingi ni kuwezesha kazi yenye ufanisi na contiguous memory (arrays, strings, buffers) kwa kutoa view ndani ya kumbukumbu iliyopo badala ya kuweka nakala mpya — ambayo ni muhimu kwa sababu allocations huunda shinikizo la GC, na katika hot paths (parsing, serialization, kuchakata data kubwa, network buffers) kuepuka allocations huboresha utendaji kwa kiasi kikubwa.
Operations ambazo kawaida huweka allocation (Substring, array slicing) zinaweza kufanyika bila allocation na spans, zikipunguza matumizi ya kumbukumbu na overhead ya GC.
Kuelewa Span<T> (zero-copy slicing ya arrays/strings/buffers), kizuizi chake cha stack-only (ni ref struct, hivyo haiwezi kuwa class field au kutumika katika async methods — kizuizi muhimu), na Memory<T> (kikamilishaji ambacho kinaweza kuhifadhiwa na kutumika katika async code) ni muhimu kwa kuandika C# ya utendaji wa juu.
Aina hizi zinatumika sana katika msimbo wa .NET wenyewe nyeti wa utendaji na kuzidi katika libraries na programu ambapo utunzaji wa kumbukumbu usio na allocation, wenye ufanisi ni muhimu.
Ingawa hazihitajiki kwa business logic ya kila siku, kuelewa Span<T>/Memory<T> — zinachofanya (memory views zisizo na allocation), kwa nini husaidia (allocations zilizopunguzwa na shinikizo la GC), na vizuizi vyao — ni jambo la thamani kwa uendelezaji wa C# nyeti wa utendaji (parsing, serialization, mifumo ya throughput ya juu), zikiwatofautisha wasanidi wanaoweza kuandika msimbo wa .NET wenye ufanisi wa juu, na ni mada inayohusika kwa nafasi za senior zinazolenga utendaji.