Thực thi trì hoãn

1. Giới thiệu

Hãy tưởng tượng: bạn vừa viết một truy vấn LINQ dài đẹp và nghĩ — “Xong rồi, mọi thứ sẽ được xử lý ngay thôi!” Nhưng rồi bạn nhận ra chẳng có gì xảy ra cho đến khi bạn đếm phần tử hoặc chuyển kết quả thành mảng. Đây không phải bug đâu, mà là feature đấy.

Trong .NET, LINQ dùng thực thi trì hoãn: truy vấn sẽ không chạy cho đến khi bạn thật sự bắt đầu lấy dữ liệu. Nó giống như một anh phục vụ lười — sẽ không chạy vào bếp cho đến khi nghe: “Mang đồ ăn ra đi!”, dù order đã ghi rồi.

Kiểu hành vi này, gọi là tính toán lười biếng (Lazy Evaluation), làm cho LINQ cực kỳ hiệu quả khi làm việc với nguồn dữ liệu lớn, thậm chí vô hạn hoặc tốn nhiều tài nguyên.

Thực thi trì hoãn nghĩa là truy vấn LINQ không chạy ngay sau khi bạn định nghĩa nó. Nó chỉ bắt đầu hoạt động khi bạn thật sự duyệt hoặc xem dữ liệu trong collection.

Ví dụ minh họa

var numbers = new List<int> { 1, 2, 3, 4, 5 };

// Truy vấn LINQ
var query = numbers.Where(n =>{
    Console.WriteLine($"Đang kiểm tra {n}");
    return n % 2 == 0;
});
Console.WriteLine("Truy vấn đã định nghĩa, nhưng chưa kiểm tra số nào cả!");

// Chỉ đến đây mới bắt đầu duyệt!
foreach (var n in query)
{
    Console.WriteLine($"Tìm thấy số chẵn: {n}");
}

Chuyện gì sẽ xảy ra?
Khi bạn chạy đoạn code này, bạn sẽ thấy trước vòng lặp foreach chẳng có gì in ra console — thậm chí điều kiện trong Where cũng chưa chạy. Chỉ khi bạn bắt đầu duyệt phần tử (ví dụ dùng foreach), truy vấn mới bắt đầu thực thi.

Đó chính là deferred execution — chưa yêu cầu thì chẳng ai làm gì cả!

2. Tại sao cần thực thi trì hoãn?

Thực thi trì hoãn không chỉ làm code gọn gàng mà còn cực kỳ hiệu quả. Tại sao phải làm việc gì đó trước, trong khi có thể kết quả chẳng bao giờ cần dùng? Điều này đặc biệt quan trọng khi bạn làm với collection lớn hoặc stream dữ liệu vẫn đang đến — tưởng tượng một nguồn có thể vô hạn. Load hết vào RAM thì quá phí phạm.

Ngoài ra, deferred execution cho phép bạn tự do kết hợp và xâu chuỗi truy vấn. Bạn có thể xây dựng các chuỗi LINQ phức tạp mà không lo chúng sẽ chạy ngay. Mọi thứ chỉ diễn ra khi bạn thật sự lấy dữ liệu — và không sớm hơn.

So sánh vui

Deferred execution giống như danh sách mua sắm trong điện thoại: bạn có thể thêm, sửa món hàng bao nhiêu cũng được, nhưng chỉ khi nào đi siêu thị thật sự thì mới dùng đến danh sách đó.

3. Nó hoạt động như thế nào bên trong?

Các truy vấn LINQ trả về IEnumerable<T> thường được cài bằng iterator (yield return) hoặc các cấu trúc lười đặc biệt. Mỗi lần bạn bắt đầu duyệt collection (ví dụ gọi foreach hoặc ToList()), truy vấn sẽ chạy lại từ đầu.

Lưu ý quan trọng

Nếu bạn thay đổi collection gốc giữa lúc định nghĩa truy vấn và lúc thực thi, dữ liệu mới hoặc đã sửa cũng sẽ xuất hiện trong kết quả.

Ví dụ:

var numbers = new List<int> { 1, 2, 3 };
var query = numbers.Where(n => n > 1);
numbers.Add(4); // thêm số mới
foreach (var n in query)
{
    Console.WriteLine(n); // sẽ in ra 2, 3, 4
}

Sơ đồ: khi nào truy vấn LINQ thực thi?

flowchart TD
    A[Định nghĩa truy vấn LINQ] --> B{Thực thi truy vấn?}
    B -- Không --> C[Chờ đợi]
    B -- Có (ví dụ, foreach, ToList) --> D[Thực thi truy vấn]
    D --> E[Kết quả hoặc hành động]

4. Ví dụ nơi "lười biếng" của LINQ phát huy tác dụng

Lọc lười biếng

var bigNumbers = Enumerable.Range(1, 1_000_000_000)
    .Where(n => n % 123_456 == 0);

foreach (var n in bigNumbers.Take(5))
{
    Console.WriteLine(n);
}

Chuyện gì xảy ra ở đây?
Truy vấn tạo ra một collection tiềm năng cả tỷ phần tử, nhưng thực tế chỉ lọc và trả về đúng 5 số thôi! Phần còn lại không bị tính toán và không chiếm RAM.

Truy vấn lồng và giao dịch

Giả sử bạn có danh sách đơn hàng và sản phẩm, và muốn lấy 5 đơn đầu tiên chứa sản phẩm nhất định.

var orders = GetBigOrderList(); // giả sử ở đây có hàng ngàn đơn

var filtered = orders
    .Where(order => order.Products.Any(p => p.Name == "Cà phê"))
    .Take(5);

foreach(var o in filtered)
{
    Console.WriteLine(o.Id);
}

LINQ sẽ không duyệt các đơn còn lại khi đã đủ 5 đơn phù hợp!

5. Những điều bất ngờ

Một số tình huống deferred execution có thể gây bất ngờ:

Thay đổi nguồn dữ liệu sau khi định nghĩa truy vấn

Như đã nói ở trên, nếu giữa lúc định nghĩa truy vấn và lúc thực thi mà collection gốc thay đổi, truy vấn sẽ thấy dữ liệu mới.

Duyệt lại một truy vấn nhiều lần

Truy vấn LINQ sẽ chạy lại mỗi lần bạn duyệt nó.

var query = numbers.Where(n => {
    Console.WriteLine($"Đang kiểm tra {n}");
    return n % 2 == 0;
});

foreach(var n in query) {} // duyệt lần 1
foreach(var n in query) {} // duyệt lần 2 — lại tính toán lại hết

Nếu bạn muốn kết quả lặp lại — hãy materialize (dùng .ToList() hoặc .ToArray()).

6. Khi nào truy vấn LINQ KHÔNG trì hoãn?

Không phải mọi thao tác LINQ đều trì hoãn. Một số method thực hiện ngay lập tức ("háu ăn") (Immediate Execution). Ví dụ:

• .ToList()
• .ToArray()
• .Count()
• .Average()
• .Sum()
• .First(), .Last(), .Single()

Tất cả các method này buộc LINQ thực thi truy vấn ngay, vì chúng trả về kết quả sẵn chứ không phải IEnumerable.

Ví dụ:

var query = numbers.Where(n => n > 2);
var result = query.ToList(); // Ở đây truy vấn sẽ chạy ngay!

7. Khái niệm "tính toán lười biếng" (Lazy Evaluation)

Deferred execution là một ví dụ cụ thể của lazy evaluation (Lazy Evaluation) trong .NET.

Lazy evaluation là khi kết quả không được tính toán cho đến khi thật sự cần. Ngoài LINQ, trong C# còn có nhiều cơ chế lazy khác.

Class Lazy<T>

C# cung cấp kiểu Lazy<T> để tạo giá trị "khi nào cần mới tính".

Ví dụ đơn giản:

// Tạo một số lười, chỉ tính khi được yêu cầu
var lazyValue = new Lazy<int>(() =>
{
    Console.WriteLine("Đang tính giá trị!");
    return 42;
});

Console.WriteLine("Đối tượng Lazy đã tạo, nhưng giá trị chưa tính");
Console.WriteLine($"Giá trị: {lazyValue.Value}"); // đến đây mới tính toán

Dùng để làm gì?
Ví dụ, bạn lưu một tham số hiếm khi dùng, và việc tính toán nó tốn thời gian hoặc tài nguyên.

8. Bảng: các method LINQ và chế độ thực thi

Where

Select

Take

Skip

Join

ToList

ToArray

Count

First

9. Lỗi thường gặp và đặc điểm khi cài đặt

"Làm việc thừa" do duyệt lại nhiều lần

Vì deferred execution sẽ tính toán lại mỗi lần duyệt, đôi khi bạn sẽ bị tính lại không cần thiết.

var expensiveQuery = bigList.Where(x => SomeHeavyCalculation(x));

var result1 = expensiveQuery.ToList(); // tính toán — lần 1
var result2 = expensiveQuery.ToList(); // tính toán — lần 2 (kết quả giống nhau nhưng tốn thời gian lại)

Cách xử lý là materialize dữ liệu một lần:
var cached = expensiveQuery.ToList();

"Bắt lỗi nếu có thể"

Nếu function trong truy vấn ném exception, nó chỉ xảy ra khi duyệt collection, không phải lúc định nghĩa truy vấn.

Sửa collection khi đang duyệt

Thay đổi collection khi đang duyệt có thể gây ra exception InvalidOperationException.