Span<T> और Memory<T> contiguous memory (arrays, strings, buffers) के साथ कुशलता से काम करने के लिए आधुनिक .NET types हैं — allocations या copying के बिना। ये नई copies बनाने के बजाय मौजूदा memory में एक view प्रदान करके high-performance कोड को सक्षम करते हैं, 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
Substring या array slicing जैसे operations नई objects allocate करते हैं और data copy करते हैं। Span<T> इसके बजाय मौजूदा memory में एक 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 को allocate किए बिना slice और process करने देता है — hot paths (parsing, serialization, बड़े data को process करना) के लिए महत्वपूर्ण।
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 विशेषताएं हैं, और इन्हें समझना performance-critical applications के लिए मूल्यवान senior-level ज्ञान है।
इनका मूल मूल्य नई copies allocate करने के बजाय मौजूदा memory में एक view प्रदान करके contiguous memory (arrays, strings, buffers) के साथ कुशल काम को सक्षम करना है — जो मायने रखता है क्योंकि allocations GC pressure पैदा करते हैं, और hot paths (parsing, serialization, बड़े data को process करना, network buffers) में allocations से बचना performance को महत्वपूर्ण रूप से बेहतर बनाता है।
ऐसे operations जो सामान्य रूप से allocate करते हैं (Substring, array slicing) spans के साथ allocation-free किए जा सकते हैं, memory usage और GC overhead को कम करते हुए।
Span<T> (arrays/strings/buffers का zero-copy slicing), इसकी stack-only बाधा (यह एक ref struct है, इसलिए यह एक class field नहीं हो सकता या async methods में उपयोग नहीं किया जा सकता — एक मुख्य सीमा), और Memory<T> (पूरक जो संग्रहीत और async कोड में उपयोग किया जा सकता है) को समझना high-performance C# लिखने के लिए महत्वपूर्ण है।
इन types का उपयोग आधुनिक .NET के अपने performance-critical कोड में व्यापक रूप से किया जाता है और libraries और applications में तेजी से जहां allocation-free, कुशल memory handling मायने रखती है।
हालांकि रोजमर्रा के business logic के लिए आवश्यक नहीं, Span<T>/Memory<T> को समझना — वे क्या करते हैं (allocation-free memory views), वे क्यों मदद करते हैं (कम allocations और GC pressure), और उनकी बाधाएं — performance-sensitive C# विकास (parsing, serialization, high-throughput systems) के लिए मूल्यवान है, उन developers को अलग करते हुए जो अत्यधिक कुशल .NET कोड लिख सकते हैं, और performance-focused senior roles के लिए एक प्रासंगिक विषय है।