Span<T> และ Memory<T> เป็นชนิดข้อมูลสมัยใหม่ของ .NET สำหรับทำงานกับ หน่วยความจำที่ต่อเนื่องกัน (array, string, buffer) อย่างมีประสิทธิภาพ — โดยไม่มีการจองหน่วยความจำหรือการคัดลอก มันช่วยให้เกิดโค้ดประสิทธิภาพสูงด้วยการให้ มุมมอง (view) เข้าไปในหน่วยความจำที่มีอยู่แทนที่จะสร้างสำเนาใหม่ ลด GC pressure
// ❌ 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 หรือการ slice array จะจองอ็อบเจกต์ใหม่และคัดลอกข้อมูล Span<T> ให้ มุมมอง (pointer + ความยาว) เข้าไปในหน่วยความจำที่มีอยู่แทน — การ slice ไม่มีต้นทุน ไม่มีการจองหน่วยความจำ
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 และประมวลผล array/string/buffer ได้โดยไม่ต้องจองหน่วยความจำ — สำคัญยิ่งสำหรับ hot path (การ parse, การ serialize, การประมวลผลข้อมูลขนาดใหญ่)
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> สำหรับสถานการณ์ที่คุณต้องเก็บมุมมองไว้หรือใช้มันในโค้ด async (ที่ธรรมชาติแบบ stack-only ของ Span<T> ใช้ไม่ได้)
Span<T> และ Memory<T> เป็นฟีเจอร์สำคัญของ .NET สมัยใหม่สำหรับโค้ด ประสิทธิภาพสูงและปราศจากการจองหน่วยความจำ และการเข้าใจมันเป็นความรู้ระดับ senior ที่มีคุณค่าสำหรับแอปพลิเคชันที่สำคัญต่อประสิทธิภาพ
คุณค่าหลักของมันคือการทำให้ทำงานกับหน่วยความจำที่ต่อเนื่องกัน (array, string, buffer) ได้อย่างมีประสิทธิภาพด้วยการให้ มุมมอง เข้าไปในหน่วยความจำที่มีอยู่แทนการจองสำเนาใหม่ — ซึ่งสำคัญเพราะการจองหน่วยความจำสร้าง GC pressure และใน hot path (การ parse, การ serialize, การประมวลผลข้อมูลขนาดใหญ่, network buffer) การหลีกเลี่ยงการจองหน่วยความจำช่วยปรับปรุงประสิทธิภาพอย่างมีนัยสำคัญ
การดำเนินการที่ปกติจะจองหน่วยความจำ (Substring, การ slice array) สามารถทำได้โดยไม่ต้องจองหน่วยความจำด้วย span ลดการใช้หน่วยความจำและ overhead ของ GC
การเข้าใจ Span<T> (zero-copy slicing ของ array/string/buffer), ข้อจำกัดแบบ stack-only ของมัน (มันเป็น ref struct ดังนั้นจึงเป็น field ของ class หรือใช้ใน async method ไม่ได้ — เป็นข้อจำกัดสำคัญ) และ Memory<T> (ตัวเสริมที่ สามารถ เก็บไว้และใช้ในโค้ด async ได้) มีความสำคัญต่อการเขียน C# ประสิทธิภาพสูง
ชนิดข้อมูลเหล่านี้ถูกใช้อย่างกว้างขวางในโค้ดที่สำคัญต่อประสิทธิภาพของ .NET เอง และมากขึ้นเรื่อย ๆ ในไลบรารีและแอปพลิเคชันที่การจัดการหน่วยความจำแบบไม่จองและมีประสิทธิภาพมีความสำคัญ
แม้จะไม่จำเป็นสำหรับ business logic ทั่วไป แต่การเข้าใจ Span<T>/Memory<T> — สิ่งที่มันทำ (มุมมองหน่วยความจำแบบไม่จองหน่วยความจำ), เหตุผลที่มันช่วย (ลดการจองหน่วยความจำและ GC pressure) และข้อจำกัดของมัน — มีคุณค่าสำหรับการพัฒนา C# ที่อ่อนไหวต่อประสิทธิภาพ (การ parse, การ serialize, ระบบ throughput สูง) แยกแยะนักพัฒนาที่สามารถเขียนโค้ด .NET ที่มีประสิทธิภาพสูงได้ และเป็นหัวข้อที่เกี่ยวข้องสำหรับบทบาทระดับ senior ที่เน้นประสิทธิภาพ