Question

如何检测ICollection的变化＆lt;＆gt;属性（多对多关系）？

public class Company
{
    ...

    public virtual ICollection<Employee> Employees { get; set; }
}

using (DataContext context = new DataContext(Properties.Settings.Default.ConnectionString))
{
    Company company = context.Companies.First();
    company.Employees.Add(context.Employees.First());

    context.SaveChanges();
}

public class DataContext : DbContext
{
    public override int SaveChanges()
    {
        return base.SaveChanges();

        // Company's entity state is "Unchanged" in this.ChangeTracker
    }
}

Answer 1

以下是如何查找所有已更改的多对多关系。我已将代码实现为扩展方法：

public static class IaExtensions
{
    public static IEnumerable<Tuple<object, object>> GetAddedRelationships(
        this DbContext context)
    {
        return GetRelationships(context, EntityState.Added, (e, i) => e.CurrentValues[i]);
    }

    public static IEnumerable<Tuple<object, object>> GetDeletedRelationships(
        this DbContext context)
    {
        return GetRelationships(context, EntityState.Deleted, (e, i) => e.OriginalValues[i]);
    }

    private static IEnumerable<Tuple<object, object>> GetRelationships(
        this DbContext context,
        EntityState relationshipState,
        Func<ObjectStateEntry, int, object> getValue)
    {
        context.ChangeTracker.DetectChanges();
        var objectContext = ((IObjectContextAdapter)context).ObjectContext;

        return objectContext
            .ObjectStateManager
            .GetObjectStateEntries(relationshipState)
            .Where(e => e.IsRelationship)
            .Select(
                e => Tuple.Create(
                    objectContext.GetObjectByKey((EntityKey)getValue(e, 0)),
                    objectContext.GetObjectByKey((EntityKey)getValue(e, 1))));
    }
}

一些解释。多对多关系在EF中表示为独立关联或IA。这是因为关系的外键不会暴露在对象模型中的任何位置。在数据库中，FK位于连接表中，并且此连接表对象模型是隐藏的。

使用＆＃34;关系条目＆＃34;在EF中跟踪IAs。它们类似于从DbContext.Entry获取的DbEntityEntry对象，除了它们表示两个实体之间的关系而不是实体本身。关系条目未在DbContext API中公开，因此您需要下拉到ObjectContext以访问它们。

创建两个实体之间的新关系时会创建新的关系条目，例如通过向Company.Employees集合添加Employee。此关系处于已添加状态。

同样，当删除两个实体之间的关系时，关系条目将进入Deleted状态。

这意味着要查找更改的多对多关系（或实际上任何已更改的IA），我们需要查找添加和删除的关系条目。这就是GetAddedRelationships和GetDeletedRelationships所做的事情。

一旦我们有关系条目，我们需要理解它们。为此，您需要了解一些内幕知识。已添加（或未更改）关系条目的CurrentValues属性包含两个值，这两个值是关系任一端的实体的EntityKey对象。同样地，但令人烦恼地略有不同，Deleted关系条目的OriginalValues属性包含已删除关系任一端的实体的EntityKey对象。

（而且，是的，这太可怕了。请不要怪我 - 这是在我的时间之前。）

CurrentValues / OriginalValues的不同之处在于我们将委托传递给GetRelationships私有方法。

一旦我们拥有EntityKey对象，我们就可以使用GetObjectByKey来获取实际的实体实例。我们将它们作为元组返回，并且你有它。

这是一些实体，一个上下文和一个初始化器，我曾经用它来测试它。（注意测试并不广泛。）

public class Company
{
    public int Id { get; set; }
    public string Name { get; set; }
    public virtual ICollection<Employee> Employees { get; set; }

    public override string ToString()
    {
        return "Company " + Name;
    }
}

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public virtual ICollection<Company> Companies { get; set; }

    public override string ToString()
    {
        return "Employee " + Name;
    }
}

public class DataContext : DbContext
{
    static DataContext()
    {
        Database.SetInitializer(new DataContextInitializer());
    }

    public DbSet<Company> Companies { get; set; }
    public DbSet<Employee> Employees { get; set; }

    public override int SaveChanges()
    {
        foreach (var relationship in this.GetAddedRelationships())
        {
            Console.WriteLine(
                "Relationship added between {0} and {1}",
                relationship.Item1,
                relationship.Item2);
        }

        foreach (var relationship in this.GetDeletedRelationships())
        {
            Console.WriteLine(
                "Relationship removed between {0} and {1}",
                relationship.Item1,
                relationship.Item2);
        }

        return base.SaveChanges();
    }

}

public class DataContextInitializer : DropCreateDatabaseAlways<DataContext>
{
    protected override void Seed(DataContext context)
    {
        var newMonics = new Company { Name = "NewMonics", Employees = new List<Employee>() };
        var microsoft = new Company { Name = "Microsoft", Employees = new List<Employee>() };

        var jim = new Employee { Name = "Jim" };
        var arthur = new Employee { Name = "Arthur" };
        var rowan = new Employee { Name = "Rowan" };

        newMonics.Employees.Add(jim);
        newMonics.Employees.Add(arthur);
        microsoft.Employees.Add(arthur);
        microsoft.Employees.Add(rowan);

        context.Companies.Add(newMonics);
        context.Companies.Add(microsoft);
    }
}

以下是使用它的示例：

using (var context = new DataContext())
{
    var microsoft = context.Companies.Single(c => c.Name == "Microsoft");
    microsoft.Employees.Add(context.Employees.Single(e => e.Name == "Jim"));

    var newMonics = context.Companies.Single(c => c.Name == "NewMonics");
    newMonics.Employees.Remove(context.Employees.Single(e => e.Name == "Arthur"));

    context.SaveChanges();
}

Answer 2

我无法向您提供适合您情况的确切代码，但我可以告诉您，通过在员工和公司之间设置一个细木工表来简化您的情况，只需打破多对多的关系。

实体框架4.1+多对多关系改变了跟踪

2 个答案: