EFCore 定义自关联

在 Entity Framework Core (EF Core) 中处理自关联（self-referencing）是非常常见的需求，尤其是在构建具有层次结构的数据模型时。例如，当你需要表示一个树形结构，如文件系统、组织架构等，自关联就非常有用。

示例场景
假设我们有一个 Category 实体类，它代表一个类别，并且一个类别可以拥有多个子类别，形成树状结构。

步骤 1: 定义实体类
定义 Category 类，并为其添加一个指向自身的导航属性 Parent 和一个包含子类别的集合 Children：

public class Category
{
    public int Id { get; set; }
    public string Name { get; set; }

    // 导航属性 - 父类别
    public Category Parent { get; set; }

    // 导航属性 - 子类别集合
    public ICollection<Category> Children { get; set; } = new HashSet<Category>();
}

步骤 2: 在 DbContext 中配置关系
在你的 DbContext 类中配置自关联关系：

public class MyDbContext : DbContext
{
    public DbSet<Category> Categories { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Category>()
            .HasOne(c => c.Parent)
            .WithMany(p => p.Children)
            .HasForeignKey(c => c.ParentId);

        modelBuilder.Entity<Category>()
            .Property(c => c.ParentId)
            .HasColumnName("ParentId"); // 显式指定外键名称
    }
}

步骤 3: 插入数据
插入数据时，需要确保正确设置父类别和子类别之间的关系：

using (var db = new MyDbContext())
{
    var rootCategory = new Category { Name = "Root" };
    var childCategory1 = new Category { Name = "Child 1", Parent = rootCategory };
    var childCategory2 = new Category { Name = "Child 2", Parent = rootCategory };
    var grandChildCategory = new Category { Name = "Grand Child", Parent = childCategory1 };

    rootCategory.Children.Add(childCategory1);
    rootCategory.Children.Add(childCategory2);
    childCategory1.Children.Add(grandChildCategory);

    db.Categories.Add(rootCategory);
    db.SaveChanges();
}

步骤 4: 查询所有子级元素
为了递归查询所有子级元素，我们可以编写一个递归方法来遍历树结构：

public static IEnumerable<Category> GetAllChildren(this Category category)
{
    if (category.Children.Any())
    {
        foreach (var child in category.Children)
        {
            yield return child;
            foreach (var grandChild in GetAllChildren(child))
            {
                yield return grandChild;
            }
        }
    }
}

然后你可以使用这个扩展方法来获取特定类别的所有子级元素：

using (var db = new MyDbContext())
{
    var rootCategory = db.Categories.Include(c => c.Children).FirstOrDefault(c => c.Name == "Root");

    if (rootCategory != null)
    {
        foreach (var child in rootCategory.GetAllChildren())
        {
            Console.WriteLine(child.Name);
        }
    }
}

这里讲解一下为什么使用yield return
yield return 是 C# 中的一个关键字，它允许你从方法中返回一系列值而不是单个值。yield return 通常与迭代器方法一起使用，使得方法能够生成一系列的值，而不需要一次性加载所有值到内存中。这种方法非常适合处理大量数据或需要按需生成数据的情况。

什么是迭代器方法？
迭代器方法是一个特殊的类型的方法，它可以返回一个枚举器（enumerator）。枚举器是一种能够逐个访问集合中元素的对象，每次调用 MoveNext 方法时，它都会移动到下一个元素。

如何使用 yield return
当在方法中使用 yield return 时，该方法会变成一个迭代器方法。迭代器方法的返回类型通常是 IEnumerable 或 IEnumerator。下面是一个简单的例子来说明这一点：

public static IEnumerable<int> GenerateNumbers(int max)
{
    for (int i = 1; i <= max; i++)
    {
        yield return i; // 每次迭代返回一个值
    }
}

在这个例子中，GenerateNumbers 方法会生成从 1 到 max 的数字序列。每执行一次循环，yield return i 就会返回当前的 i 值，但不会结束整个方法。相反，它会“挂起”当前状态，直到再次被调用时才继续执行。

使用 yield return 的好处
延迟执行：只有在调用 GetEnumerator 并迭代时才会执行方法中的代码。
节省内存：不需要一次性将所有结果加载到内存中。
按需计算：只在需要的时候计算下一个值。

使用 yield return 可以让你轻松地创建迭代器方法，这些方法可以生成大量的数据，同时又不会占用过多的内存。这对于处理大型数据集尤其有用，因为它允许你在数据生成时按需处理每一项数据，而不是一次性加载所有数据。在处理自关联结构时，yield return 的延迟执行特性尤其有价值，因为它可以避免不必要的内存消耗，并使代码更高效、更易于管理。