Span<T> agus Memory<T> ná cineálacha nua-aimseartha .NET do dhúil a dhéanamh le cuimhne dhlúth (eagar, teaghraigh, maolchluichí) go héifeachtach — gan dháilíochtaí nó cóipeáil. Tugann siad deis do chód ard-fheidhmíochta trí radharc a sholáthar ar chuimhne atá ann cheana féin seachas cóipeanna nua a chruthú, rud a laghdaíonn an brú ar 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
Oibríochtaí ar nós Substring nó gearradh eagar a dhíolúnann réada nua agus sonraí a chóipeáil. Span<T> seachas sin a sholáthraíonn radharc (pointeoir + fad) ar chuimhne atá ann cheana — níl aon chostas ar ghearradh, níl dháilíochtaí ar bith ann.
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
Ligann Span<T> duit sliseanna a ghearradh agus eagair/teaghraigh/maolchluichí a phróiseáil gan dháilíochtaí — ríthábhachtach do chonairí te (fógra, srathaithe, próiseáil sonraí móra).
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
}
Déanann Memory<T> comhlánú ar Span<T> do staidreamh ina mbíonn gá agat an radharc a stóráil nó a úsáid i gcód async (áit ina bhfuil nádúr stack-amháin Span<T> gan obair).
Is gné thábhachtach nua-aimseartha .NET iad Span<T> agus Memory<T> do chód ard-fheidhmíochta, gan dháilíochtaí, agus tá eolas orthu ina bhailchríoch ar fhiosrúchán ar leibhéal sinsearach do fheidhmchritéir ríthábhachtacha do na feidhmíochta.
Is é an luach bunúsach atá iontu a dhéanamh ar fhéidearthacht iontrucht a dhéanamh le cuimhne dhilis (eagair, teaghraigh, maolchluichí) trí radharc a sholáthar ar chuimhne atá ann cheana féin in ionad cóipeanna nua a dháilíochtú — rud a bhíonn ábhartha toisc go gcruthaíonn dháilíochtaí brú GC, agus i conairí te (fógra, srathaithe, próiseáil sonraí móra, maolchluichí líonra) laghdaíonn seachaint ar dhailíochtaí an fheidhmíocht go mór.
Is féidir oibríochtaí a ngnáthdháilíonn (Substring, gearradh eagar) a dhéanamh gan dháilíochtaí le spans, rud a laghdaíonn úsáid chuimhne agus fothram GC.
Tá tuiscint ar Span<T> (sliseanna gan chóipeáil d'eagair/teaghraigh/maolchluichí), a srian stack-amháin (is ref struct a bhí ann, mar sin ní féidir é a bheith i réimse aicme nó a úsáid i modhanna async — srian lárnach), agus Memory<T> (an comhlánú is féidir a stóráil agus a úsáid i gcód async) tábhachtach do C# ard-fheidhmíochta a scríobh.
Cé nach gá iad do ghnáth-loighic gnó, tá tuiscint ar Span<T>/Memory<T> — céard a dhéanann siad (radhairc cuimhne gan dháilíochtaí), cén fáth a chabhraíonn siad leo (dháilíochtaí laghdaithe agus brú GC), agus a bhfithim — luachmhar do fhorbirt C# mothúchán-bharrúil (fógra, srathaithe, córais ard-iompar), ag fágáil gur forbairteoirí is féidir leo cód .NET an-éifeachtach a scríobh, agus i réimse ábhartha do róil sinsearach ar dhírithe ar fheidhmíochta.