Span<T> és Memory<T> modern .NET típusok a szomszédos memória (tömbök, stringek, bufferek) hatékony kezeléséhez — foglalások vagy másolások nélkül. Magas teljesítményű kódot tesznek lehetővé azáltal, hogy nézetet biztosítanak a meglévő memóriába ahelyett, hogy új másolatokat hoznának létre, így csökkentve a GC terhelést.
// ❌ 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
Az olyan műveletek, mint a Substring vagy a tömbszeletelés új objektumokat foglalnak és másolnak adatokat. A Span<T> helyette nézetet (pointer + hossz) biztosít a meglévő memóriába — a szeletelés semmi költséggel jár, semmit nem foglal le.
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
A Span<T> lehetővé teszi a tömbök/stringek/bufferek szeletelését és feldolgozását foglalás nélkül — kritikus a forró utakban (elemzés, szerializáció, nagy adatok feldolgozása).
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
}
A Memory<T> kiegészíti a Span<T>-t olyan forgatókönyvekhez, ahol a nézetet tárolni kell vagy aszinkron kódban kell használni (ahol a Span<T> csak stack-ben való jellege nem működik).
A Span<T> és Memory<T> fontos modern .NET funkciók a nagy teljesítményű, foglalás-mentes kódhoz, és megértésük értékes senior szintű tudás a teljesítménykritikus alkalmazások számára.
Az alapvető értékük a szomszédos memória (tömbök, stringek, bufferek) hatékony kezeléséhez való hozzáférés nyújtásban egy nézet biztosítása útján a meglévő memóriába ahelyett, hogy új másolatokat hoznának létre — ez azért számít, mert a foglalások GC terhelést hoznak létre, és a forró utakban (elemzés, szerializáció, nagy adatok feldolgozása, hálózati bufferek) a foglalások elkerülése jelentősen javítja a teljesítményt.
Azok a műveletek, amelyek normálisan foglalnak (Substring, tömbszeletelés) span-ekkel foglalás-mentes módon végezhetők el, csökkentve a memóriahasználatot és a GC overhead-et.
A Span<T> (tömbök/stringek/bufferek másolás nélküli szeletelése), annak csak stack-ben való megkötése (ez egy ref struct, tehát nem lehet egy osztály mezője vagy aszinkron metódusokban használni — egy kulcsfontosságú korlátozás), és a Memory<T> (a kiegészítés, amely lehet tárolva és aszinkron kódban használva) megértése fontos a nagy teljesítményű C# írásához.
Ezeket a típusokat széles körben alkalmazzák a modern .NET saját teljesítménykritikus kódjában és egyre inkább olyan könyvtárakban és alkalmazásokban, ahol a foglalás-mentes, hatékony memóriakezelés számít.
Bár nem szükséges a mindennapi üzleti logikához, a Span<T>/Memory<T> megértése — amit csinálnak (foglalás-mentes memóriavizsgálat), miért segítenek (csökkent foglalások és GC terhelés), és korlátai — értékes a teljesítménysensitív C# fejlesztéshez (elemzés, szerializáció, nagy áteresztőképességű rendszerek), megkülönböztetik azokat a fejlesztőket, akik nagy hatékonysággal tudnak .NET kódot írni, és releváns témakör a teljesítményfókuszú senior szerepekhez.