Span<T> आणि Memory<T> आधुनिक .NET प्रकार आहेत जे सतत मेमोरी (arrays, strings, buffers) सह कार्य करण्यासाठी कार्यक्षमतेने वापरले जातात — वाटप किंवा कॉपी न करता. ते विद्यमान मेमोरीमध्ये एक दृश्य प्रदान करून उच्च-कार्यक्षमता कोड सक्षम करतात, नव्या प्रती तयार न करता, 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 स्लाइसिंग सारख्या ऑपरेशन्स नवीन ऑब्जेक्ट्स वाटपित करतात आणि डेटा कॉपी करतात. Span<T> त्याऐवजी विद्यमान मेमोरीमध्ये एक दृश्य (pointer + length) प्रदान करते — स्लाइसिंग खर्च नाही, काहीही वाटप करत नाही.
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 स्लाइस आणि प्रक्रिया करू देते वाटपित न करता — hot paths (पार्सिंग, सीरियलाइজेशन, मोठ्या डेटा प्रक्रिया) साठी महत्वपूर्ण.
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> ज्या परिस्थितींमध्ये तुम्हाला दृश्य संचयित करायचे किंवा async कोडमध्ये वापरायचे (जेथे Span<T>ची stack-केवळ मर्यादा काम करत नाही) त्यासाठी Span<T> पूरक करते.
Span<T> आणि Memory<T> उच्च-कार्यक्षमता, वाटपित-मुक्त कोडसाठी महत्वाचे आधुनिक .NET वैशिष्ट्य आहेत, आणि त्यांना समजून घेणे कार्यक्षमता-गंभीर अनुप्रयोगांसाठी मूल्यवान सीनियर-स्तरीय ज्ञान आहे.
त्यांचे मूळ मूल्य विद्यमान मेमोरीमध्ये एक दृश्य प्रदान करून सतत मेमोरी (arrays, strings, buffers) सह कार्यक्षम कार्य सक्षम करणे आहे — नवीन प्रती वाटपित न करता — जे महत्वाचे आहे कारण वाटपीकरण GC दबाव तयार करते, आणि hot paths (पार्सिंग, सीरियलाइजेशन, मोठ्या डेटा प्रक्रिया, नेटवर्क buffers) मध्ये वाटपीकरण टाळणे कार्यक्षमता लक्षणीयरित्या सुधारते.
सामान्यत: वाटपीकरण करणारी ऑपरेशन्स (Substring, array स्लाइसिंग) spans सह वाटपीकरण-मुक्त करता येतात, मेमोरी वापर आणि GC ओव्हरहेड कमी करतात.
Span<T> (arrays/strings/buffers ची शून्य-प्रतिलिपी स्लाइसिंग), त्याची स्टॅक-केवळ मर्यादा (हे ref struct आहे, म्हणून हे क्लास फील्ड असू शकत नाही किंवा async पद्धतींमध्ये वापरले जाऊ शकत नाही — एक मुख्य मर्यादा), आणि Memory<T> (पूरक जो संचयित आणि async कोडमध्ये वापरला जाऊ शकतो) समजून घेणे उच्च-कार्यक्षमता C# लिहिण्यासाठी महत्वाचे आहे.
हे प्रकार आधुनिक .NET च्या स्वतःच्या कार्यक्षमता-गंभीर कोडमध्ये व्यापकपणे वापरले जातात आणि वाढत्या मापदंडात libraries आणि applications मध्ये जेथे वाटपीकरण-मुक्त, कार्यक्षम मेमोरी हँडलिंग महत्वाचे आहे.
रोजचे व्यावसायिक तर्कासाठी आवश्यक नसले तरी, Span<T>/Memory<T> समजून घेणे — ते काय करतात (वाटपीकरण-मुक्त मेमोरी दृश्य), का मदत करतात (कमी वाटपीकरण आणि GC दबाव), आणि त्यांच्या मर्यादा — कार्यक्षमता-संवेदनशील C# विकासासाठी मूल्यवान आहे (पार्सिंग, सीरियलाइजेशन, उच्च-throughput systems), जे developers जो अत्यंत कार्यक्षम .NET कोड लिहू शकतो ते वेगळे करतात, आणि कार्यक्षमता-केंद्रित सीनियर भूमिकांसाठी संबंधित विषय आहे.
सविस्तर उत्तरांसह IT मुलाखत प्रश्नांचे ग्रंथालय — Junior पासून Senior पर्यंत.
देणगी द्या