Span<T> და Memory<T> არის თანამედროვე .NET ტიპები, რომლებიც მუშაობენ contiguous memory-ს (მასივები, სტრიქონები, buffers) ეფექტურად — დაკიდებული ობიექტების ან დაკოპირების გარეშე. ისინი საშუალებას იძლევა high-performance კოდის დაწერას იმ გზით, რომ view იძლევიან არსებული მეხსიერების მიხედვით, ვიდრე ახალი ასლების შექმნით, რაც 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 ან მასივის slicing ოპერაციები ახალ ობიექტებს ცარიელი და ქვესახელს აქვთ. Span<T> იმის ნაცვლად უძღვება view (pointer + length) არსებული მეხსიერებაში — slicing ღირებულობა არაფერი, allocates არაფერი.
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> საშუალებას გაძლევთ slice და დამუშავე მასივები/სტრიქონები/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> ავსებს Span<T>-ს სცენარებისთვის, სადაც გჭირდებათ view-ს შენახვა ან მისი გამოყენება async კოდში (სადაც Span<T>-ის stack-only ბუნება არ მოქმედებს).
Span<T> და Memory<T> არის მნიშვნელოვანი თანამედროვე .NET ფიচები high-performance, allocation-free კოდისთვის, და მათი გაგება ღირებული senior-level ცოდნაა performance-critical აპლიკაციებისთვის.
მათი ძირითადი მნიშვნელობა არის contiguous memory-ს (მასივები, სტრიქონები, buffers) ეფექტური მუშაობის დაშვება view-ის მეშვეობით არსებული მეხსიერებაში, ვიდრე ახალი ასლების allocate - რაც მნიშვნელოვანია, რადგან allocations აქმნის GC pressure-ს, და hot paths-ში (parsing, serialization, დიდი მონაცემების დამუშავება, network buffers) allocations-ის თავიდან აცილება მნიშვნელოვნად უმჯობესებს performance-ს.
ოპერაციები, რომლებიც ჩვეულებრივ allocate (Substring, მასივის slicing) შეიძლება გაკეთდეს allocation-free-ად spans-ის გამოყენებით, რაც ამცირებს მეხსიერების გამოყენებას და GC overhead-ს.
Span<T> (მასივების/სტრიქონების/buffers-ის zero-copy slicing) გაგება, მისი stack-only შეზღუდვა (ეს არის ref struct, ამიტომ ეს არ შეიძლება იყოს კლასის field ან გამოიყენება async methods-ში — ძირითადი შეზღუდვა), და Memory<T> (კომპლიმენტი, რომელიც შეიძლება შენახული და გამოიყენებოდეს async კოდში) მნიშვნელოვანია high-performance C#-ის დასაწერად.
ეს ტიპები ფართოდ გამოიყენება თანამედროვე .NET-ის საკუთარ performance-critical კოდში და სულ უფრო მეტი ბიბლიოთეკებში და აპლიკაციებში, სადაც allocation-free, ეფექტური მეხსიერების მართვა მნიშვნელოვანია.
მიუხედავად იმისა, რომ არ არის საჭირო ყოველდღიური ბიზნეს ლოგიკისთვის, Span<T>/Memory<T> გაგება — რა აქვთ საქმე (allocation-free memory views), რატომ ხელმძღვანელობს ისინი (ამცირებული allocations და GC pressure) და მათი შეზღუდვები — ღირებულია performance-sensitive C# განვითარებისთვის (parsing, serialization, high-throughput სისტემები), განასხვავებს განვითარებულ ადამიანებს, რომელსაც შეუძლია დაწეროს ძალიან ეფექტური .NET კოდი, და არის relevant თემა performance-focused senior როლებისთვის.