Span<T> மற்றும் Memory<T> ஆகியவை தொடர்ச்சியான நினைவகத்துடன் (arrays, strings, buffers) திறமையாக பணிபுரிய நவீன .NET வகைகள் — இவை ஒதுக்கீடுகள் அல்லது நகலெடுப்பு இல்லாமல் செயல்படுகின்றன. 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 போன்ற செயல்பாடுகள் புதிய பொருள்களை ஒதுக்கி தரவை நகலெடுக்கின்றன. அதற்கு பதிலாக Span<T> தொடர்ச்சியான நினைவகத்தில் பார்வை (pointer + length) வழங்குகிறது — slicing எந்த செலவும் ஆகாது, எந்த ஒதுக்கீடும் ஆகாது.
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 மற்றும் செயல்பாடு செய்ய அனுமதிக்கிறது — 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> இன் பூரணபদம்: நீங்கள் பார்வையை சேமிக்க அல்லது async குறியீட்டில் பயன்படுத்த வேண்டிய சூழ்நிலைகளுக்கு (Span<T> இன் stack-only தன்மை வேலை செய்யாத இடங்களில்).
Span<T> மற்றும் Memory<T> ஆகியவை உচ்च-செயல்திறன், ஒதுக்கீடு-இல்லாத குறியீட்டுக்கான நவீன .NET அம்சங்கள், மற்றும் அவற்றைப் புரிந்துகொள்வது செயல்திறன்-முக்கியமான பயன்பாடுகளுக்கான மதிப்புள்ள senior-level அறிவாகும்.
அவற்றின் முக்கிய மதிப்பு தொடர்ச்சியான நினைவகத்துடன் (arrays, strings, buffers) திறமையாக பணிபுரிய பார்வை வழங்குவதன் மூலம் புதிய நகல்களை ஒதுக்குவதை அனுமதிப்பது — இது முக்கியமாக உள்ளது ஏனெனில் ஒதுக்கீடுகள் GC அழுத்தத்தை உருவாக்குகின்றன, மற்றும் hot paths (parsing, serialization, பெரிய தரவு செயல்பாடு, நெட்வொர்க் buffers) இல் ஒதுக்கீடுகளைத் தவிர்ப்பது செயல்திறனை கணிசமாக மேம்படுத்துகிறது.
சாதாரணமாக ஒதுக்கப்படும் செயல்பாடுகள் (Substring, array slicing) spans உடன் ஒதுக்கீடு-இல்லாமல் செய்யப்படலாம், நினைவக பயன்பாடு மற்றும் GC overheadலை குறைக்கிறது.
Span<T> (arrays/strings/buffers இன் zero-copy slicing), அதன் stack-only கட்டுப்பாடு (இது ref struct ஆகும், எனவே இது ஒரு class field அல்லது async methods இல் பயன்படுத்த முடியாது — ஒரு முக்கிய கட்டுப்பாடு), மற்றும் Memory<T> (சேமிக்கப்படக்கூடிய மற்றும் async குறியீட்டில் பயன்படுத்தக்கூடிய பூரணபதம்) ஆகியவற்றைப் புரிந்துகொள்வது உচ்च-செயல்திறன் C# எழுத தக்கதாகும்.
இந்த வகைகள் நவீன .NET இன் சொந்த செயல்திறன்-முக்கியமான குறியீட்டில் பரவலாக பயன்படுத்தப்படுகின்றன மற்றும் ஒதுக்கீடு-இல்லாத, திறமையான நினைவக handling மக்கள் முக்கியமாக இருக்கும் நூலகங்கள் மற்றும் பயன்பாடுகளில் ஏறிக்கொண்டு வருகிறது.
இது தினசரி வணிக தர்க்கத்திற்கு தேவையில்லை என்றாலும், Span<T>/Memory<T> ஐ புரிந்துகொள்வது — அவை என்ன செய்கின்றன (ஒதுக்கீடு-இல்லாத நினைவக பார்வைகள்), ஏன் அவை உதவுகின்றன (குறைக்கப்பட்ட ஒதுக்கீடுகள் மற்றும் GC அழுத்தம்), மற்றும் அவற்றின் கட்டுப்பாடுகள் — செயல்திறன்-உணர்வுள்ள C# மேம்பாட்டுக்கு (parsing, serialization, உচ்च-throughput systems) மதிப்புள்ளது, உচ்च-செயல்திறன் .NET குறியீட்டை எழுத முடியும் developers ஐ வேறுபடுத்துகிறது, மற்றும் செயல்திறன்-கவனம் வைக்கப்பட்ட senior பாத்திரங்களுக்கு பொருந்தக்கூடிய விষயமாகும்.
விரிவான பதில்களுடன் கூடிய IT நேர்காணல் கேள்விகளின் நூலகம் — Junior முதல் Senior வரை.
நன்கொடை