Span<T> và Memory<T> là các kiểu .NET hiện đại để làm việc với bộ nhớ liền kề (contiguous memory) (mảng, string, buffer) một cách hiệu quả — không cấp phát hay sao chép. Chúng cho phép code hiệu năng cao bằng việc cung cấp một góc nhìn (view) vào bộ nhớ hiện có thay vì tạo các bản sao mới, giảm áp lực GC.
// ❌ Substring cấp phát một string MỚI (sao chép dữ liệu) — áp lực GC trong hot path
string text = "Hello, World";
string sub = text.Substring(7); // cấp phát một string "World" mới
// ✅ Span — một GÓC NHÌN vào bộ nhớ hiện có, KHÔNG cấp phát, KHÔNG sao chép
ReadOnlySpan<char> span = text.AsSpan(7); // "World" — trỏ vào bản gốc
Các thao tác như Substring hay cắt lát mảng cấp phát object mới và sao chép dữ liệu. Span<T> thay vào đó cung cấp một góc nhìn (con trỏ + độ dài) vào bộ nhớ hiện có — cắt lát không tốn gì, không cấp phát gì.
int[] numbers = { 1, 2, 3, 4, 5 };
Span<int> slice = numbers.AsSpan(1, 3); // {2, 3, 4} — một GÓC NHÌN, không sao chép
slice[0] = 99; // sửa mảng GỐC (nó là một góc nhìn)
// phân tích cú pháp không cấp phát substring
ReadOnlySpan<char> input = "123,456".AsSpan();
int first = int.Parse(input.Slice(0, 3)); // parse một slice, không cấp phát substring
Span<T> cho phép bạn cắt lát và xử lý mảng/string/buffer mà không cấp phát — then chốt cho hot path (parsing, serialization, xử lý dữ liệu lớn).
Span<T> là một ref struct — nó CHỈ có thể nằm trên stack (không trên heap, không trong
method async, không làm field của class). Điều này đảm bảo an toàn nhưng giới hạn nơi dùng được.
// Memory<T> giống Span<T> nhưng CÓ THỂ là field / dùng qua await (lưu được trên heap)
async Task ProcessAsync(Memory<byte> buffer) // hoạt động trong async (Span<T> không thể)
{
await stream.ReadAsync(buffer);
Span<byte> span = buffer.Span; // lấy một Span từ nó khi cần xử lý
}
Memory<T> bổ sung cho Span<T> cho các kịch bản nơi bạn cần lưu trữ góc nhìn hoặc dùng nó trong code async (nơi bản chất chỉ-trên-stack của Span<T> không hoạt động).
Span<T> và Memory<T> là các tính năng .NET hiện đại quan trọng cho code hiệu năng cao, không cấp phát, và hiểu chúng là kiến thức cấp senior có giá trị cho các ứng dụng nhạy cảm hiệu năng.
Giá trị cốt lõi của chúng là cho phép làm việc hiệu quả với bộ nhớ liền kề (mảng, string, buffer) bằng việc cung cấp một góc nhìn vào bộ nhớ hiện có thay vì cấp phát các bản sao mới — điều này có ý nghĩa vì cấp phát tạo ra áp lực GC, và trong các hot path (parsing, serialization, xử lý dữ liệu lớn, network buffer) tránh cấp phát cải thiện đáng kể hiệu năng.
Các thao tác thường cấp phát (Substring, cắt lát mảng) có thể được làm không cấp phát với span, giảm sử dụng bộ nhớ và chi phí GC.
Hiểu Span<T> (cắt lát không sao chép mảng/string/buffer), ràng buộc chỉ-trên-stack của nó (nó là một ref struct, nên không thể là field của class hay dùng trong method async — một giới hạn then chốt), và Memory<T> (cái bổ sung có thể được lưu trữ và dùng trong code async) là quan trọng để viết C# hiệu năng cao.
Các kiểu này được dùng rộng rãi trong chính code nhạy cảm hiệu năng của .NET hiện đại và ngày càng nhiều trong các thư viện và ứng dụng nơi xử lý bộ nhớ không cấp phát, hiệu quả có ý nghĩa.
Tuy không cần cho logic nghiệp vụ hằng ngày, hiểu Span<T>/Memory<T> — chúng làm gì (góc nhìn bộ nhớ không cấp phát), vì sao chúng giúp ích (giảm cấp phát và áp lực GC), và các ràng buộc của chúng — là có giá trị cho việc phát triển C# nhạy cảm hiệu năng (parsing, serialization, các hệ thống thông lượng cao), phân biệt các lập trình viên có thể viết code .NET hiệu quả cao, và là một chủ đề liên quan cho các vị trí senior tập trung hiệu năng.