Span<T> અને Memory<T> એ આધુનિક .NET પ્રકારો છે જે સંલગ્ન મેમોરી (arrays, strings, buffers) સાથે કાર્યક્ષમતાથી કામ કરવા માટે છે — કોઈ allocations અથવા copying વિના. તેઓ હાય-પરફોર્મન્સ કોડ સક્ષમ બનાવે છે view પ્રદાન કરીને હાલની મેમોરીમાં તેના બદલે નવી copies બનાવવાની જરૂર નથી, જે 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
Substring અથવા array slicing જેવી ક્રિયાઓ નવી objects allocate કરે છે અને ડેટા કૉપી કરે છે. Span<T> તેના બદલે view (pointer + length) પ્રદાન કરે છે હાલની મેમોરીમાં — slicing કંઈ કિંમતે આવતું નથી, કંઈ allocate કરતું નથી.
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> તમને arrays/strings/buffers slice અને પ્રોસેસ કરવા દે છે allocate કર્યા વિના — hot paths માટે જરૂરી છે (parsing, serialization, મોટા ડેટા પ્રોસેસિંગ).
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> Span<T> ને પૂરક બનાવે છે ધ情ણોમાં જ્યાં તમે view સ્ટોર કરવી જોઈએ અથવા તેને async કોડમાં ઉપયોગ કરી શકો (Span<T>ની stack-only પ્રકૃતિ ત્યાં કાર્ય કરતી નથી).
Span<T> અને Memory<T> એ high-performance, allocation-free કોડ માટે આધુનિક .NET ફીચરો છે, અને તેમને સમજવું high-performance-critical applications માટે વલ્યુેબલ senior-level જ્ઞાન છે.
તેમની મૂળ વેલ્યુ એ છે કે સંલગ્ન મેમોરી (arrays, strings, buffers) સાથે કાર્યક્ષમ કામ સક્ષમ બનાવવું view પ્રદાન કરીને હાલની મેમોરીમાં તેના બદલે નવી copies allocate કર્યા વિના — જે મહત્વપૂર્ણ છે કારણ કે allocations GC દબાણ બનાવે છે, અને hot paths (parsing, serialization, મોટા ડેટા પ્રોસેસિંગ, network buffers) માં allocations ટાળવું કર્મક્ષમતાને નોંધપાત્ર રીતે સુધારે છે.
ક્રિયાઓ જે સામાન્ય રીતે allocate કરે છે (Substring, array slicing) spans સાથે allocation-free કરી શકાય છે, જે મેમોરી ઉપયોગ અને GC overhead ઘટાડે છે.
Span<T> (arrays/strings/buffers ની zero-copy slicing), તનું stack-only constraint (તે ref struct છે, તેથી તે class field હોઈ શકતું નથી અથવા async methods માં ઉપયોગ કરી શકાતું નથી — એક મુખ્ય મર્યાદા), અને Memory<T> (complement જે હોઈ શકે સ્ટોર કરી શકાય અને async કોડમાં ઉપયોગ કરી શકાય) સમજવું high-performance C# લખવા માટે મહત્વપૂર્ણ છે.
આ પ્રકારો આધુનિક .NET ની પોતાની performance-critical કોડમાં વ્યાપકપણે ઉપયોગ થાય છે અને increasingly libraries અને applications માં જ્યાં allocation-free, કાર્યક્ષમ મેમોરી હેન્ડલિંગ મહત્વપૂર્ણ છે.
જ્યારે દૈનિક business logic માટે જરૂર નથી, Span<T>/Memory<T> સમજવું — તેઓ શું કરે છે (allocation-free memory views), શા માટે તેઓ મદદ કરે છે (ઘટેલા allocations અને GC દબાણ), અને તેમની મર્યાદાઓ — performance-sensitive C# development (parsing, serialization, high-throughput systems) માટે વલ્યુેબલ છે, ડેવલપર્સને તફાવત આપે છે જેઓ extremely efficient .NET કોડ લખી શકે છે, અને performance-focused senior roles માટે સંબંધિત વિષય છે.