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

Question

如何检测ICollection<>属性的更改(多对多关系)?

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中表示为独立协会(IAs)。这是因为关系的外键没有在对象模型的任何地方公开。在数据库中，fk位于一个连接表中，这个连接表对对象模型是隐藏的。

在EF中使用"关系条目"跟踪IAs。这些类似于从DbContext获得的DbEntityEntry对象。条目，除了它们表示两个实体之间的关系而不是实体本身。关系项没有在DbContext API中公开，因此您需要下拉到ObjectContext来访问它们。

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

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

这意味着要找到已更改的多对多关系(或者实际上是任何已更改的IA)，我们需要找到添加和删除的关系条目。这就是getadddedrelationships和GetDeletedRelationships所做的。

一旦我们有了关系项，我们就需要理解它们。为此，你需要知道一些内幕消息。添加(或未更改)关系条目的CurrentValues属性包含两个值，它们是关系两端实体的EntityKey对象。类似地，但有一点令人恼火的不同，已删除关系条目的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

我不能给你具体的代码，但是我可以告诉你，通过在Employees和Company之间添加一个joiner表来打破多对多的关系，你的情况将简化十倍。