如何使用Entity Framework和AutoMapper处理实体循环引用？

问题场景 #

我正在学习如何使用Entity Framework和AutoMapper处理实体关联，尤其是循环引用问题。

实体类定义 #

public class Author
{
    public string id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public IEnumerable<Book>? Books { get; set; }
}
public class Book
{
    public string id { get; set; }
    public string Name { get; set; }

    public Author Author { get; set; }
    public IEnumerable<Page>? Pages { get; set; }
}
public class Page
{
    public string id { get; set; }
    public string Text { get; set; }

    public Book Book { get; set; }
    public Author Author { get; set; }
}

期望返回结构 #

查询Author时的期望结构

{
    "id": "author1",
    "firstName": "famous",
    "lastName": "author",
    "books": [
        {
            "id": "book1",
            "name": "famousBookName",
            "pages": [
                {
                    "id": "page1",
                    "text": "..."
                },
                {
                    "id": "page2",
                    "text": "..."
                }
            ]
        }
    ]
}

查询Book时的期望结构

{
    "id": "book1",
    "name": "famousBookName",
    "author": {
        "id": "author1",
        "firstName": "famous",
        "lastName": "author"
    },
    "pages": [
        {
            "id": "page1",
            "text": "..."
        },
        {
            "id": "page2",
            "text": "..."
        }
    ]
}

查询Page时的期望结构

{
    "id": "page1",
    "text": "...",
    "book": {
        "id": "book1",
        "name": "famousBookName"
    },
    "author": {
        "id": "author1",
        "firstName": "famous",
        "lastName": "author"
    }
}

实际问题：循环引用导致无限嵌套 #

当前查询返回的结果存在循环引用，出现无限嵌套的情况：

{
    "id": "author1",
    "firstName": "famous",
    "lastName": "author",
    "books": [
        {
            "id": "book1",
            "name": "famousBookName",
            "pages": [
                {
                    "id": "page1",
                    "text": "...",
                    "book": {
                        "id": "book1",
                        "name": "famousBookName",
                        "author": {
                            "id": "author1",
                            "firstName": "famous",
                            "lastName": "author",
                            "books": [...]
                        },
                        "pages": [...]
                    },
                    "author": {
                        "id": "author1",
                        "firstName": "famous",
                        "lastName": "author",
                        "books": [...]
                    }
                }
            ]
        }
    ]
}

问题解答 #

1. 能否通过Entity Framework配置避免填充循环引用？ #

可以从两个层面处理：

• 序列化层面忽略循环：在ASP.NET Core中配置JSON序列化选项，让序列化器自动截断循环引用，不会改变实体本身的关联数据，但能避免输出无限嵌套：

builder.Services.AddControllers()
    .AddJsonOptions(options =>
    {
        options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
    });

• 数据加载层面控制关联：使用EF的投影查询（Select），只加载需要的字段和关联，从根源避免加载不需要的反向关联。比如查询Author时，只加载Books的基础信息和Pages的id、Text，不加载Book的Author和Page的Book/Author：

var authors = await dbContext.Authors
    .Select(a => new 
    {
        a.id,
        a.FirstName,
        a.LastName,
        Books = a.Books.Select(b => new 
        {
            b.id,
            b.Name,
            Pages = b.Pages.Select(p => new { p.id, p.Text })
        })
    })
    .ToListAsync();

这种方式会让EF生成更高效的SQL，只查询需要的字段，同时避免循环数据。

2. 能否通过AutoMapper设置解决该问题？ #

可以，AutoMapper提供了多种方式处理循环引用：

• 精准配置映射规则：针对不同的查询场景，配置对应的映射，忽略不需要的反向关联字段。比如为Author查询场景创建专用的DTO映射：

// 定义DTO
public class AuthorDto
{
    public string id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public IEnumerable<BookDtoForAuthor> Books { get; set; }
}

public class BookDtoForAuthor
{
    public string id { get; set; }
    public string Name { get; set; }
    public IEnumerable<PageDtoForBook> Pages { get; set; }
}

public class PageDtoForBook
{
    public string id { get; set; }
    public string Text { get; set; }
}

// 配置AutoMapper映射
CreateMap<Author, AuthorDto>();
CreateMap<Book, BookDtoForAuthor>()
    .ForMember(dest => dest.Author, opt => opt.Ignore()); // 忽略Book的Author关联，避免循环
CreateMap<Page, PageDtoForBook>()
    .ForMember(dest => dest.Book, opt => opt.Ignore())
    .ForMember(dest => dest.Author, opt => opt.Ignore());

• 全局设置最大映射深度：通过MaxDepth限制映射的层级，超过层级后停止映射，但这种方式不够灵活，适合简单场景：

var config = new MapperConfiguration(cfg =>
{
    cfg.CreateMap<Author, AuthorDto>();
    cfg.CreateMap<Book, BookDto>();
    cfg.CreateMap<Page, PageDto>();
    cfg.MaxDepth(3); // 设置最大映射深度为3
});

• 使用ProjectTo生成高效查询：AutoMapper的ProjectTo方法可以将映射规则转换为EF的SQL查询，只加载需要的字段，同时避免循环：

var authors = await dbContext.Authors
    .ProjectTo<AuthorDto>(mapper.ConfigurationProvider)
    .ToListAsync();

3. 是否必须创建多个DTO类？ #

不是必须，但推荐创建针对性的DTO。虽然项目扩张后DTO数量会增加，但这是分层架构中隔离领域模型与展示模型的最佳实践：

• 不同查询场景需要不同的返回结构，DTO可以精准匹配需求，避免暴露不必要的字段；
• 实体类的变更不会直接影响API输出，提高系统稳定性；
• 如果不想创建过多DTO，可以使用AutoMapper的条件映射或动态投影，但灵活性和可维护性不如专用DTO。

4. 使用.Select()手动映射到匿名类型是否属于最佳实践？ #

在简单场景下可行，但不是长期的最佳实践：

• 优点：无需额外创建DTO，代码简洁，EF会生成高效的SQL（仅查询需要的字段）；
• 缺点：匿名类型无法复用，复杂场景下代码会冗长；无法进行数据验证、序列化配置等操作；多场景重复使用时会产生冗余代码。

对于复杂项目或需要复用的场景，推荐使用DTO配合AutoMapper，或者使用AutoMapper的ProjectTo方法，兼顾查询效率和代码可维护性。

内容的提问来源于stack exchange，提问作者Simon