Span<T> మరియు Memory<T> అనేవి సమీప్య మెమరీ (arrays, strings, buffers) తో సమర్థవంతంగా పని చేయడానికి ఆధునిక .NET రకాలు — కేటాయింపులు లేదా నకలు చేయకుండా. వారు ఇప్పటికే ఉన్న మెమరీలోకి వీక్షణ ను అందించడం ద్వారా అధిక-పనితీరు కోడ్ను ఎనభల్ చేస్తారు, కొత్త కాపీలను సృష్టించే బదులు, GC ఒత్తిడిని తగ్గిస్తారు.
text = ;
sub = text.Substring();
ReadOnlySpan<> span = text.AsSpan();
Substring లేదా array slicing వంటి కార్యకలాపాలు కొత్త వస్తువులను కేటాయించి డేటాను కాపీ చేస్తాయి. 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 (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> వీక్షణను నిల్వ చేయవలసిన లేదా async కోడ్లో దాన్ని ఉపయోగించవలసిన సన్నివేశాల కోసం Span<T> ను పూరక చేస్తుంది (ఇక్కడ Span<T> యొక్క స్టాక్-మాత్రమే స్వభావం పని చేయదు).
Span<T> మరియు Memory<T> అధిక-పనితీరు, కేటాయింపు-రహిత కోడ్ కోసం ముఖ్యమైన ఆధునిక .NET లక్షణాలు, మరియు పనితీరు-సమీప్య అనువర్తనాల కోసం వాటిని అర్థం చేసుకోవడం విలువైన సీనియర్-స్థర ఎక్కడైనా జ్ఞానం.
వాటి ప్రధాన విలువ సమీప్య మెమరీ (arrays, strings, buffers) తో సమర్థవంతంగా పని చేయడం ఎనభల్ చేయడం ద్వారా ఇప్పటికే ఉన్న మెమరీలోకి వీక్షణ ను అందించడం ద్వారా కొత్త కాపీలను కేటాయించకుండా — ఇది ముఖ్యమైనది ఎందుకంటే కేటాయింపులు GC ఒత్తిడిని సృష్టిస్తాయి, మరియు hot paths లో (parsing, serialization, పెద్ద డేటా ప్రక్రియ చేయడం, నెట్వర్క్ buffers) కేటాయింపులను నివారించడం పనితీరును గణనీయంగా మెరుగుపరుస్తుంది.
సాధారణంగా కేటాయించే కార్యకలాపాలు (Substring, array slicing) spans తో కేటాయింపు-రహితంగా చేయవచ్చు, మెమరీ వినియోగం మరియు GC ఓవర్హెడ్ను తగ్గిస్తుంది.
Span<T> (arrays/strings/buffers యొక్క సున్నా-కాపీ స్లైసింగ్), దాని స్టాక్-మాత్రమే నియంత్రణ (ఇది ref struct, కాబట్టి ఇది తరగతి ఫీల్డ్ కాదా async పద్ధతులలో ఉపయోగించబడదు — ఒక ముఖ్యమైన పరిమితి), మరియు Memory<T> (స్టోర్ చేయబడుతుంది మరియు async కోడ్లో ఉపయోగించబడుతుంది) ను అర్థం చేసుకోవడం అధిక-పనితీరు C# లో రాయడానికి ముఖ్యమైనది.
ఈ రకాలు ఆధునిక .NET యొక్క స్వంత పనితీరు-సమీప్య కోడ్లో విస్తృతంగా ఉపయోగించబడతాయి మరియు కేటాయింపు-రహిత, సమర్థవంతమైన మెమరీ నిర్వహణ ముఖ్యమైన లైబ్రరీలు మరియు అనువర్తనాలలో క్రమంగా ఉపయోగించబడతాయి.
రోజువారీ వ్యాపార తర్కం కోసం అవసరం లేనప్పటికీ, Span<T>/Memory<T> — వారు ఏమి చేస్తారు (కేటాయింపు-రహిత మెమరీ వీక్షణలు), ఎందుకు సహాయపడతారు (తగ్గిన కేటాయింపులు మరియు GC ఒత్తిడి), మరియు వాటి నియంత్రణలను అర్థం చేసుకోవడం పనితీరు-సున్నితమైన C# అభివృద్ధిలో (parsing, serialization, అధిక-throughput వ్యవస్థలు) విలువైనది, అధిక సమర్థవంతమైన .NET కోడ్ను వ్రాయగల డెవలపర్లను వేరుచేయడం, మరియు పనితీరు-కేంద్రీకృత సీనియర్ పాత్రల కోసం సంబంధితమైన విషయం.