Span<T> ਅਤੇ Memory<T> ਆਧੁਨਿਕ .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 ਜਾਂ ਐਰੇ ਸਲਾਇਸਿੰਗ ਵਰਗੀਆਂ ਕਾਰਵਾਈਆਂ ਨਵੀਆਂ ਆਬਜੈਕਟਾਂ ਨੂੰ ਅਲਾਕ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਡਾਟਾ ਕਾਪੀ ਕਰਦੀਆਂ ਹਨ। Span<T> ਇਸ ਦੀ ਬਜਾਏ ਮੌਜੂਦਾ ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕ ਦ੍ਰਿਸ਼ (ਪੁਆਇੰਟਰ + ਲੰਬਾਈ) ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ — ਸਲਾਇਸਿੰਗ ਕੁਝ ਨਹੀਂ ਲਾਗੂ ਕਰਦੀ, ਕੁਝ ਅਲਾਕ ਨਹੀਂ ਕਰਦੀ।
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> ਤੁਹਾਨੂੰ ਐਰੇ/ਸਟ੍ਰਿੰਗ/ਬਫਰ ਨੂੰ ਅਲਾਕ ਕੀਤੇ ਬਿਨਾਂ ਸਲਾਈਸ ਕਰਨ ਅਤੇ ਪ੍ਰਸੰਸਕਿਤ ਕਰਨ ਦਿਓ — ਗਰਮ ਪਾਥ (ਪਾਰਸਿੰਗ, ਸੀਰੀਲਾਈਜ਼ੇਸ਼ਨ, ਵੱਡਾ ਡਾਟਾ ਪ੍ਰਸੰਸਕਰਨ) ਲਈ ਮਹੱਤਵਪੂਰਨ।
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> ਦੇ ਲਈ ਉਹ ਪ੍ਰਸਥਿਤੀਆਂ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਦ੍ਰਿਸ਼ ਨੂੰ ਸਟੋਰ ਕਰਨਾ ਜਾਂ ਇਸ ਨੂੰ ਅਸਿੰਕ ਕੋਡ ਵਿੱਚ ਵਰਤਣਾ ਪਵੇ (ਜਿੱਥੇ Span<T> ਦੀ ਸਟੈਕ-ਓਨਲੀ ਪ੍ਰਕਿਰਿਆ ਕਾਮ ਨਹੀਂ ਕਰਦੀ)।
Span<T> ਅਤੇ Memory<T> ਆਧੁਨਿਕ .NET ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ, ਅਲਾਕੇਸ਼ਨ-ਮੁਕਤ ਕੋਡ ਲਈ, ਅਤੇ ਇਨ੍ਹਾਂ ਨੂੰ ਸਮਝਣਾ ਕਾਰਜਕਾਰਣ-ਸੰਵੇਦਨਸ਼ੀਲ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਵਰਿਸ਼ਠ-ਸਤਰ ਦਾ ਗਿਆਨ ਹੈ।
ਇਨ੍ਹਾਂ ਦਾ ਮੁੱਖ ਮੁੱਲ ਨਿਰੰਤਰ ਮੈਮੋਰੀ (ਐਰੇ, ਸਟ੍ਰਿੰਗ, ਬਫਰ) ਦੇ ਨਾਲ ਕੁਸ਼ਲ ਕਾਮ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣਾ ਹੈ ਮੌਜੂਦਾ ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕ ਦ੍ਰਿਸ਼ ਪ੍ਰਦਾਨ ਕਰਕੇ ਨਵੀਆਂ ਕਾਪੀਆਂ ਅਲਾਕ ਕਰਨ ਦੀ ਬਜਾਏ — ਜੋ ਫ਼ਰਕ ਪਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਅਲਾਕੇਸ਼ਨ GC ਦਬਾਅ ਬਣਾਉਂਦੀ ਹੈ, ਅਤੇ ਗਰਮ ਪਾਥ (ਪਾਰਸਿੰਗ, ਸੀਰੀਲਾਈਜ਼ੇਸ਼ਨ, ਵੱਡਾ ਡਾਟਾ ਪ੍ਰਸੰਸਕਰਨ, ਨੈੱਟਵਰਕ ਬਫਰ) ਵਿੱਚ ਅਲਾਕੇਸ਼ਨ ਤੋਂ ਬਚਣਾ ਬਹੁਤ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ।
ਆਮ ਤੌਰ 'ਤੇ ਅਲਾਕ ਕਰਨ ਵਾਲੀਆਂ ਕਾਰਵਾਈਆਂ (Substring, ਐਰੇ ਸਲਾਇਸਿੰਗ) ਨੂੰ ਸਪੌਨ ਦੇ ਨਾਲ ਅਲਾਕੇਸ਼ਨ-ਮੁਕਤ ਤਰੀਕੇ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਮੈਮੋਰੀ ਵਰਤੋਂ ਅਤੇ GC ਸੰਚਾਲਨ ਨੂੰ ਘਟਾ ਕੇ।
Span<T> (ਐਰੇ/ਸਟ੍ਰਿੰਗ/ਬਫਰ ਦੀ ਜ਼ੀਰੋ-ਕਾਪੀ ਸਲਾਇਸਿੰਗ), ਇਸ ਸਟੈਕ-ਓਨਲੀ ਰੋਕ ਨੂੰ ਸਮਝਣਾ (ਇਹ ref struct ਹੈ, ਇਸ ਲਈ ਇਹ ਕਲਾਸ ਫੀਲਡ ਨਹੀਂ ਹੋ ਸਕਦਾ ਜਾਂ ਅਸਿੰਕ ਤਰੀਕਿਆਂ ਵਿੱਚ ਵਰਤਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ — ਇੱਕ ਮੁੱਖ ਸੀਮਾਬੱਧਤਾ), ਅਤੇ Memory<T> (ਪੂਰਕ ਜੋ ਸਟੋਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਅਸਿੰਕ ਕੋਡ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ) ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ C# ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।
ਇਹ ਕਿਸਮਾਂ ਆਧੁਨਿਕ .NET ਦੇ ਆਪਣੇ ਕਾਰਜਕਾਰਣ-ਸੰਵੇਦਨਸ਼ੀਲ ਕੋਡ ਵਿੱਚ ਵਿਆਪਕ ਰੂਪ ਨਾਲ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਉਦੋਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਵਧ ਰਹੀਆਂ ਹਨ ਜਿੱਥੇ ਅਲਾਕੇਸ਼ਨ-ਮੁਕਤ, ਕੁਸ਼ਲ ਮੈਮੋਰੀ ਹੈਂਡਲਿੰਗ ਮੂਲ ਹੈ।
aਰੋਜ਼ਮਰਾ ਦੇ ਵਪਾਰ ਅਨੁਸੂਚੀ ਲਈ ਜਰੂਰੀ ਨਹੀਂ ਹੋਣ 'ਤੇ ਵੀ, Span<T>/Memory<T> ਨੂੰ ਸਮਝਣਾ — ਇਹ ਕੀ ਕਰਦੇ ਹਨ (ਅਲਾਕੇਸ਼ਨ-ਮੁਕਤ ਮੈਮੋਰੀ ਦ੍ਰਿਸ਼), ਇਹ ਮਦਦ ਕਿਉਂ ਕਰਦੇ ਹਨ (ਘਟਾਈ ਗਈ ਅਲਾਕੇਸ਼ਨ ਅਤੇ GC ਦਬਾਅ), ਅਤੇ ਇਨ੍ਹਾਂ ਦੀਆਂ ਸੀਮਾਬੱਧਤਾਵਾਂ — ਕਾਰਜਕਾਰਣ-ਸੰਵੇਦਨਸ਼ੀਲ C# ਵਿਕਾਸ (ਪਾਰਸਿੰਗ, ਸੀਰੀਲਾਈਜ਼ੇਸ਼ਨ, ਉੱਚ-ਥਰੂਪੁੱਟ ਪ੍ਰਣਾਲੀਆਂ), ਵਿਕਾਸਕਰਤਾਵਾਂ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ ਜੋ ਅਤਿ ਕੁਸ਼ਲ .NET ਕੋਡ ਲਿਖ ਸਕਦੇ ਹਨ, ਅਤੇ ਕਾਰਜਕਾਰਣ-ਕੇਂਦ੍ਰਿਤ ਵਰਿਸ਼ਠ ਭੂਮਿਕਾਵਾਂ ਲਈ ਪ੍ਰাਸੰਗਿਕ ਵਿਸ਼ਾ ਹੈ।