IEnumerable và yield return trong C#: giải thích chuỗi lazy

Mọi vòng lặp foreach và mọi truy vấn LINQ đều hoạt động qua một interface nhỏ: IEnumerable<T>. Hiểu nó sẽ giải thích vì sao LINQ là lazy, vì sao có những chuỗi chỉ đọc được một lần, và cách yield return giúp bạn tự viết chuỗi của mình chỉ bằng một vòng lặp thông thường.

IEnumerable là gì

IEnumerable<T> có một phương thức duy nhất, GetEnumerator(). Enumerator mà nó trả về có MoveNext() (tiến lên, và báo còn phần tử hay không) và Current (phần tử hiện tại). Một vòng foreach là cách viết tắt để điều khiển enumerator đó:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        IEnumerable<string> colors = new List<string> { "red", "green", "blue" };

        foreach (string c in colors)
        {
            Console.Write(c + " ");
        }
        Console.WriteLine();

        // What the foreach above compiles to, roughly:
        using (IEnumerator<string> e = colors.GetEnumerator())
        {
            while (e.MoveNext())
            {
                Console.Write(e.Current + " ");
            }
        }
        Console.WriteLine();
    }
}

Đầu ra:

red green blue 
red green blue 

Enumerator bắt đầu ở trước phần tử đầu tiên, nên lần MoveNext() đầu tiên di chuyển tới phần tử đó. Khi MoveNext() trả về false, chuỗi kết thúc. Khối using giải phóng (dispose) enumerator, điều này quan trọng với các iterator giữ tài nguyên như tệp đang mở.

IEnumerable, ICollection và List

Các interface collection tạo thành một bậc thang. Mỗi bậc hứa hẹn nhiều hơn:

Một phương thức chỉ lặp qua đầu vào nên nhận IEnumerable<T>, để nơi gọi có thể truyền mảng, list, set hay truy vấn LINQ mà không cần chuyển đổi. Một phương thức trả về dữ liệu thường nên trả về thứ gì đó cho biết "dữ liệu này đã nằm trong bộ nhớ", như List<T> hoặc IReadOnlyList<T>, vì giá trị trả về kiểu IEnumerable<T> có thể là một truy vấn phải làm lại việc mỗi lần được đọc.

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static decimal Total(IEnumerable<decimal> amounts)
    {
        decimal sum = 0;
        foreach (decimal a in amounts) sum += a;
        return sum;
    }

    static void Main()
    {
        decimal[] array = { 10m, 20m };
        var list = new List<decimal> { 5m, 5m, 5m };
        var set = new HashSet<decimal> { 1.5m, 2.5m };

        Console.WriteLine(Total(array));
        Console.WriteLine(Total(list));
        Console.WriteLine(Total(set));
        Console.WriteLine(Total(list.Where(x => x > 1m).Select(x => x * 2)));
    }
}

Đầu ra:

30
15
4.0
30

Viết iterator bằng yield return

Để tạo chuỗi của riêng bạn, hãy viết một phương thức trả về IEnumerable<T> và dùng yield return cho từng phần tử. Trình biên dịch biến phương thức đó thành một lớp triển khai enumerator giúp bạn.

using System;
using System.Collections.Generic;

class Program
{
    static IEnumerable<int> EvenNumbers(int max)
    {
        for (int i = 0; i <= max; i += 2)
        {
            yield return i;
        }
    }

    static IEnumerable<string> Weekdays()
    {
        yield return "Mon";
        yield return "Tue";
        yield return "Wed";
        yield return "Thu";
        yield return "Fri";
    }

    static void Main()
    {
        Console.WriteLine(string.Join(", ", EvenNumbers(10)));
        foreach (string d in Weekdays())
        {
            Console.Write(d + " ");
        }
        Console.WriteLine();
    }
}

Đầu ra:

0, 2, 4, 6, 8, 10
Mon Tue Wed Thu Fri 

Không có list nào trong EvenNumbers. Mỗi yield return giao một giá trị cho nơi gọi rồi tạm dừng phương thức, giữ các biến cục bộ (ở đây là i) tồn tại cho đến khi nơi gọi xin giá trị tiếp theo.

Lazy: để ý thứ tự thực thi

Vì phương thức tạm dừng, phần thân của nó và vòng lặp của nơi gọi thay phiên nhau chạy. In ra từ cả hai phía sẽ cho thấy sự đan xen đó:

using System;
using System.Collections.Generic;

class Program
{
    static IEnumerable<int> Numbers()
    {
        Console.WriteLine("  start");
        for (int i = 1; i <= 3; i++)
        {
            Console.WriteLine("  yielding " + i);
            yield return i;
            Console.WriteLine("  resumed after " + i);
        }
        Console.WriteLine("  end");
    }

    static void Main()
    {
        IEnumerable<int> seq = Numbers();
        Console.WriteLine("Called Numbers(), nothing printed yet");

        foreach (int n in seq)
        {
            Console.WriteLine("Loop got " + n);
        }
    }
}

Đầu ra:

Called Numbers(), nothing printed yet
  start
  yielding 1
Loop got 1
  resumed after 1
  yielding 2
Loop got 2
  resumed after 2
  yielding 3
Loop got 3
  resumed after 3
  end

Gọi Numbers() không in ra "start": lời gọi đó chỉ tạo ra đối tượng enumerable. Phần thân bắt đầu chạy ở lần MoveNext() đầu tiên bên trong foreach, chạy tới yield return đầu tiên rồi dừng. Mỗi bước sau đó chạy tiếp từ dòng ngay sau yield. Where và Select của LINQ cũng hoạt động như vậy (runtime triển khai chúng bằng các lớp enumerator viết tay để chạy nhanh hơn, nhưng hiệu quả giống hệt), đó là lý do truy vấn LINQ được thực thi trễ (deferred).

yield break

yield break kết thúc chuỗi sớm, là phiên bản return của iterator:

using System;
using System.Collections.Generic;

class Program
{
    static IEnumerable<string> ReadUntilBlank(string[] lines)
    {
        foreach (string line in lines)
        {
            if (line.Trim().Length == 0)
            {
                yield break; // stop at the first blank line
            }
            yield return line.Trim();
        }
    }

    static void Main()
    {
        string[] input = { "Subject: Invoice", " From: shop@example.com", "", "Body text" };
        foreach (string header in ReadUntilBlank(input))
        {
            Console.WriteLine(header);
        }
    }
}

Đầu ra:

Subject: Invoice
From: shop@example.com

Bạn không thể trộn return value; với yield return trong cùng một phương thức. Khi một phương thức đã chứa yield, nó là một iterator, và yield break là cách duy nhất để thoát sớm.

Chuỗi vô hạn

Vì chỉ những phần tử được yêu cầu mới được tính, một iterator có thể mô tả một chuỗi không có điểm kết thúc. Bên sử dụng quyết định lấy bao nhiêu:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static IEnumerable<long> Fibonacci()
    {
        long a = 0, b = 1;
        while (true)
        {
            yield return a;
            long next = a + b;
            a = b;
            b = next;
        }
    }

    static IEnumerable<DateTime> Mondays(DateTime from)
    {
        DateTime d = from;
        while (d.DayOfWeek != DayOfWeek.Monday) d = d.AddDays(1);
        while (true)
        {
            yield return d;
            d = d.AddDays(7);
        }
    }

    static void Main()
    {
        Console.WriteLine(string.Join(", ", Fibonacci().Take(10)));
        Console.WriteLine(Fibonacci().First(f => f > 1000));

        foreach (DateTime m in Mondays(new DateTime(2026, 9, 24)).Take(3))
        {
            Console.WriteLine(m.ToString("yyyy-MM-dd ddd"));
        }
    }
}

Đầu ra:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34
1597
2026-09-28 Mon
2026-10-05 Mon
2026-10-12 Mon

while (true) an toàn ở đây vì Take và First ngừng xin thêm khi đã có đủ thứ chúng cần. Ngược lại, gọi ToList() hoặc Count() trên một chuỗi vô hạn sẽ không bao giờ trả về, và duyệt một OrderBy trên chuỗi đó cũng vậy, vì sắp xếp cần có mọi phần tử trước.

Cạm bẫy của chuỗi lazy

Kiểm tra đối số chạy muộn. Toàn bộ phần thân của iterator bị trì hoãn, kể cả phần kiểm tra ở đầu. Cách khắc phục là tách phương thức: một phương thức thông thường kiểm tra đối số rồi trả về kết quả của một iterator private.

using System;
using System.Collections.Generic;

class Program
{
    static IEnumerable<int> LazyRange(int count)
    {
        if (count < 0) throw new ArgumentOutOfRangeException("count");
        for (int i = 0; i < count; i++) yield return i;
    }

    static IEnumerable<int> EagerRange(int count)
    {
        if (count < 0) throw new ArgumentOutOfRangeException("count"); // runs now
        return RangeIterator(count);
    }

    static IEnumerable<int> RangeIterator(int count)
    {
        for (int i = 0; i < count; i++) yield return i;
    }

    static void Main()
    {
        IEnumerable<int> a = LazyRange(-1);
        Console.WriteLine("LazyRange(-1) returned without an error");
        try
        {
            foreach (int x in a) { }
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine("...and threw only when enumerated");
        }

        try
        {
            EagerRange(-1);
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine("EagerRange(-1) threw at the call");
        }
    }
}

Đầu ra:

LazyRange(-1) returned without an error
...and threw only when enumerated
EagerRange(-1) threw at the call

Mỗi lần duyệt lại chạy phương thức từ đầu. Iterator không lưu đệm gì cả. Lặp hai lần qua Numbers() sẽ in "start" hai lần, đọc lại tệp hai lần, hoặc gọi web service hai lần. Các IDE cảnh báo điều này là "possible multiple enumeration of IEnumerable". Hãy gọi ToList() một lần khi bạn cần dùng các phần tử nhiều hơn một lần.

finally chạy khi bên sử dụng dừng lại. Nếu nơi gọi thoát khỏi foreach sớm, enumerator được giải phóng và mọi khối finally trong iterator đều chạy, đó là cách một iterator đọc tệp đóng được tệp:

using System;
using System.Collections.Generic;

class Program
{
    static IEnumerable<int> Readings()
    {
        Console.WriteLine("open sensor");
        try
        {
            for (int i = 1; i <= 100; i++) yield return i * 10;
        }
        finally
        {
            Console.WriteLine("close sensor");
        }
    }

    static void Main()
    {
        foreach (int r in Readings())
        {
            Console.WriteLine(r);
            if (r >= 30) break;
        }
        Console.WriteLine("done");
    }
}

Đầu ra:

open sensor
10
20
30
close sensor
done

Một vài quy tắc trình biên dịch áp đặt lên iterator: yield return không được nằm trong khối try có catch (dùng try/finally thì được), trong lambda hoặc phương thức ẩn danh, hoặc trong phương thức có tham số ref hay out.

Async stream

Với những chuỗi có phần tử đến một cách bất đồng bộ (các trang dữ liệu từ API, các hàng từ cơ sở dữ liệu), C# 8 trở lên (với .NET Core 3.0 trở lên) kết hợp iterator với await thông qua IAsyncEnumerable<T>:

static async IAsyncEnumerable<string> FetchPages()
{
    for (int page = 1; page <= 3; page++)
    {
        await Task.Delay(100);           // simulate a network call
        yield return $"page {page}";
    }
}

await foreach (string p in FetchPages())
{
    Console.WriteLine(p);
}

Bên sử dụng dùng await foreach, và mỗi phần tử được await ngay khi nó được tạo ra.

Lỗi thường gặp

• Trả về IEnumerable<T> từ một truy vấn rồi đọc nó nhiều lần. Mỗi lần đọc chạy lại truy vấn; hãy trả về List<T> thay vào đó.
• Kiểm tra đối số bên trong iterator. Bước kiểm tra bị trì hoãn; hãy tách thành một phương thức bọc ngoài và một iterator.
• Gọi Count() hoặc ToList() trên một iterator vô hạn. Nó không bao giờ kết thúc; hãy Take trước.
• Mong tham số IEnumerable<T> có Count hoặc [i]. Hãy dùng Count() của LINQ (có thể phải duyệt) hoặc nhận IReadOnlyList<T>.