EF Core 7：如何添加导航属性而不加载实际实体？

方案1：在Adapter中统一复用上下文跟踪的Employee实例 #

核心思路是拿到外部返回的订单后，先将每个订单关联的Employee替换为应用上下文已跟踪（或新增）的实例，避免重复创建同ID的Employee实体导致跟踪冲突。

修改Adapter的Update方法：

public void Update(int projectId)
{
    var project = context.Projects.Find(projectId);
    var updates = external.FetchOrders(projectId);
    // 用字典缓存已处理的Employee，避免重复查询或创建
    var employeeCache = new Dictionary<int, Employee>();

    foreach(var update in updates)
    {
        if(!project.Orders.Any(x => x.Id == update.Id))
        {
            // 处理Employee关联
            int employeeId = update.Employee.Id;
            if(!employeeCache.TryGetValue(employeeId, out var existingEmployee))
            {
                // 先从上下文查找是否已存在该Employee
                existingEmployee = context.Employees.Find(employeeId);
                if(existingEmployee == null)
                {
                    // 不存在则创建新实例并添加到上下文
                    existingEmployee = new Employee { Id = employeeId };
                    context.Employees.Add(existingEmployee);
                }
                employeeCache[employeeId] = existingEmployee;
            }
            // 替换订单的Employee为上下文跟踪的实例
            update.Employee = existingEmployee;
            project.Orders.Add(update);
        }
    }

    context.SaveChanges();
}

方案2：用DTO解耦ExternalRepo与领域实体 #

让ExternalRepo返回**数据传输对象（DTO）**而非直接返回Order实体，彻底切断外部仓储与应用上下文实体的依赖，同时避免实体跟踪问题。

步骤1：定义DTO类 #

public class OrderDto
{
    public int Id { get; set; }
    public int EmployeeId { get; set; }
}

步骤2：修改ExternalRepo返回DTO #

public class ExternalRepo
{
    public List<OrderDto> FetchOrders(int projectId)
    {
        var orderDtos = new List<OrderDto>();

        // 从外部数据库读取数据
        orderDtos.Add(new OrderDto()
        {
            Id = (int)sqlReader["orderId"],
            EmployeeId = (int)sqlReader["employeeId"]
        });

        return orderDtos;
    }
}

步骤3：Adapter中转换DTO为实体并关联上下文 #

public class Adapter 
{
    private ExternalRepo external;
    private AppContext context;

    public void Update(int projectId)
    {
        var project = context.Projects.Find(projectId);
        var orderDtos = external.FetchOrders(projectId);
        var employeeCache = new Dictionary<int, Employee>();

        foreach(var dto in orderDtos)
        {
            if(!project.Orders.Any(x => x.Id == dto.Id))
            {
                // 获取或创建上下文跟踪的Employee
                if(!employeeCache.TryGetValue(dto.EmployeeId, out var employee))
                {
                    employee = context.Employees.Find(dto.EmployeeId) ?? new Employee { Id = dto.EmployeeId };
                    if(context.Entry(employee).State == EntityState.Detached)
                    {
                        context.Employees.Add(employee);
                    }
                    employeeCache[dto.EmployeeId] = employee;
                }
                // 创建Order实体并关联
                var order = new Order { Id = dto.Id, Employee = employee };
                project.Orders.Add(order);
            }
        }

        context.SaveChanges();
    }
}

方案3：使用EF Core的Attach方法管理跟踪状态 #

如果不想修改ExternalRepo的返回类型，也可以在Adapter中对重复的Employee实体进行状态管理，确保同ID的Employee只有一个被上下文跟踪：

public void Update(int projectId)
{
    var project = context.Projects.Find(projectId);
    var updates = external.FetchOrders(projectId);
    var trackedEmployeeIds = new HashSet<int>();

    foreach(var update in updates)
    {
        if(!project.Orders.Any(x => x.Id == update.Id))
        {
            var employee = update.Employee;
            if(trackedEmployeeIds.Contains(employee.Id))
            {
                // 替换为已跟踪的实例
                update.Employee = context.Employees.Local.First(e => e.Id == employee.Id);
            }
            else
            {
                // 检查上下文是否已跟踪该Employee
                var existing = context.Employees.Find(employee.Id);
                if(existing != null)
                {
                    update.Employee = existing;
                }
                else
                {
                    // 附加新实例到上下文
                    context.Attach(employee);
                    trackedEmployeeIds.Add(employee.Id);
                }
            }
            project.Orders.Add(update);
        }
    }

    context.SaveChanges();
}

设计优化建议 #

• 坚持关注点分离：ExternalRepo只负责获取外部数据，不应涉及应用上下文的实体操作，用DTO传输数据是最彻底的解耦方式。
• 引入缓存机制：对于频繁查询的Employee，可以在Adapter层或上下文层添加缓存，减少数据库查询次数。
• 考虑批量操作：如果同步的数据量较大，建议使用EF Core的AddRange替代逐个添加，提升性能。

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