许多一对多的关系，左右键后，实体框架5的升级翻转 [英] Many-to-many relationship left and right keys flipped after Entity Framework 5 upgrade

问题描述

我有一些代码，节省了许多在代码中的许多关系。它是工作的罚款与实体框架4.1，但更新到实体框架5后，它的失败

我收到以下错误：

INSERT语句冲突与外键约束FK_WebUserFavouriteEvent_Event。冲突发生于数据库MainEvents，表dbo.Event，列ID。

我使用POCO实体与自定义映射。标准领域，多到一的关系映射似乎是工作的罚款。

更新

好了，我已经得到了SQL事件探查器安装和剧情有增厚...

  EXEC sp_executesql的N'插入[DBO]。[WebUserFavouriteEvent]（[WebUserId]，[事件ID]）
值（@ 0，@ 1）
'N'@ 0 INT，@ 1诠释'，@ 0 = 1820 @ 1 = 14 
  

这意味着：

  WebUserId = @ 0 = 1820 
 EVENTID = @ 1 = 14 
  

有趣的是的是的 EF5似乎周围翻转外键 ...在 WebUserId应为14 和 EVENTID应是1820 ，而不是其他方式周围像它现在。

我回顾了映射代码和我99％我已经设置了这一切正确。请参见实体框架流利API - 关系MSDN文章更多信息

注意：我还发现，这并不仅限于节约要么，选用也破

下面是所有相关的代码：

服务层

 公共无效AddFavEvent（WEBUSER WEBUSER，事件@event）
 {
 webUser.FavouriteEvents.Add（@event）; 
 
 _webUserRepo.Update（WEBUSER）; 
} 
  

库

 公共无效更新< T>（PARAMS T []实体）
，其中T：DBTABLE 
 {
的foreach（VAR实体在实体）
 {
 entity.UpdatedOn = DateTime.UtcNow; 
} 
 
 _dbContext.SaveChanges（）; 
} 
  

注意：我使用的是1的DataContext每个请求的方式，所以 WEBUSER 和 @event 将被从相同的上下文加载一个在 _webUserRepo 。

实体（不用担心DBTABLE东西）

 公共类的事件：DBTABLE 
 {
 // BLAH 
公共虚拟的ICollection<&WEBUSER GT; FavouriteOf {搞定;组; } 
 // BLAH 
} 
 
公共类WEBUSER：DBTABLE 
 {
 // BLAH 
公共虚拟的ICollection<事件> FavouriteEvents {搞定;组; } 
 // BLAH 
} 
  

映射

 公共类EventMapping资料：DbTableMapping<事件> 
 {
公共EventMapping资料（）
 {
 ToTable（事件）; 
 // BLAH 
的hasMany（X => x.FavouriteOf）
 .WithMany（X => x.FavouriteEvents）
 .MAP（X => 
 {
 x.MapLeftKey（事件ID）; 
 x.MapRightKey（WebUserId）; 
 x.ToTable（WebUserFavouriteEvent）; 
}）; 
} 
} 
 
公共类WebUserMapping：DbTableMapping<&WEBUSER GT; 
 {
公共WebUserMapping（）
 {
的hasMany（X => x.FavouriteEvents）
 .WithMany（X => x.FavouriteOf）
 .MAP（M = GT; 
 {
 m.MapLeftKey（WebUserId）; 
 m.MapRightKey（事件ID）; 
 m.ToTable（WebUserFavouriteEvent ）; 
}）; 
} 
} 
  

解决方案

展望在这我怀疑问题可能是由你映射了相同的关系两倍的事实引起的。而你在不同的顺序将其映射

我做了一个简单的测试，在那里我第一次映射一旦关系：

 类节目
 {
静态无效的主要（字串[] args）
 {
 Database.SetInitializer（新DropCreateDatabaseAlways<语境>（） ）; 
变种P =新的父（）; 
变种C =新的儿童（）;使用（VAR DB =新的上下文（））
 {
 db.Parents.Add 
（新的父（））; 
 db.Parents.Add（对）; 
 
 db.Children.Add（C）; 
 db.SaveChanges（）; 
}使用
 
（VAR DB =新的上下文（））
 {
 VAR reloadedP = db.Parents.Find（p.ParentId）; 
 VAR reloadedC = db.Children.Find（c.ChildId）; 
 
 reloadedP.Children =新的List<儿童>（）; 
 reloadedP.Children.Add（reloadedC）; 
 
 db.SaveChanges（）; 
}使用
 
（VAR DB =新的上下文（））
 {
 Console.WriteLine（db.Children.Count（））; 
 Console.WriteLine（db.Children.Where（CH => ch.ChildId == c.ChildId）。选择（CH => ch.Parents.Count）。首先（））; 
 Console.WriteLine（db.Parents.Where（PA => pa.ParentId == p.ParentId）。选择（PA => pa.Children.Count）。首先（））; 
} 
} 
} 
 
公共类父
 {
公众诠释的ParentId {搞定;组; } 
公众的ICollection<儿童>儿童{搞定;组; } 
 
} 
 
公共类儿童
 {
公众诠释childID的{搞定;组; } 
公众的ICollection<家长和GT;家长{搞定;组; } 
} 
 
公共类语境的DbContext 
 {
公共语境（）：基地（数据源=的Mikael-PC;集成安全性= SSPI;初始目录= EFTest）
 {
 
} 
 
公共IDbSet<儿童>儿童{搞定;组; } 
公共IDbSet<家长和GT;家长{搞定;组; } 
 
保护覆盖无效OnModelCreating（DbModelBuilder模型构建器）
 {
 base.OnModelCreating（模型构建器）; 
 modelBuilder.Entity<儿童>（）
 .HasMany（X => x.Parents）
 .WithMany（X => x.Children）
 .MAP（C = GT; 
 {
 c.MapLeftKey（childID的）; 
 c.MapRightKey（的ParentId）; 
 c.ToTable（ChildToParentMapping）; 
}）; 
 
} 
} 
  

然后我改变了OnModelCreating到是：

 保护覆盖无效OnModelCreating（DbModelBuilder模型构建器）
 {
 base.OnModelCreating（模型构建器）; 
 modelBuilder.Entity<儿童>（）
 .HasMany（X => x.Parents）
 .WithMany（X => x.Children）
 .MAP（C = GT; 
 {
 c.MapLeftKey（childID的）; 
 c.MapRightKey（的ParentId）; 
 c.ToTable（ChildToParentMapping）; 
}）; 
 
 modelBuilder.Entity<家长和GT;（）
 .HasMany（X => x.Children）
 .WithMany（X => x.Parents）
 .MAP（C => 
 {
 c.MapLeftKey（的ParentId）; 
 c.MapRightKey（childID的）; 
 c.ToTable（ChildToParentMapping） ; 
}）; 
} 
  

我发现和怀疑的是，第一次运行生成此SQL：

  EXEC sp_executesql的N'insert [DBO]。[ChildToParentMapping]（[childID的]，[的ParentId]）
值（@ 0，@ 1）
'N'@ 0 INT，@ 1诠释'，@ 0 = 1，@ 1 = 2 
  

在constrast第二个产生：

  EXEC sp_executesql的N'insert [DBO] [ChildToParentMapping]（[的ParentId]，[childID的]）
值（@ 0，@ 1）
'N'@ 0 INT，@ 1诠释'，@ 0 = 1，@ 1 = 2 
  

您看到翻转的价值观？这实际上算上childID的列的ParentId。现在，这并不为崩溃我，但我让EF创建，这意味着它可能只是切换的列名，如果我想看看他们会太切换外键的数据库。如果你创建了数据库手动，这将可能不会是这样

因此，在短期：你的映射是不相等的，我希望要使用的其中之一，一个可能是错的。在较早版本我想EF拿了就以不同的顺序。

更新：
我有点好奇外键，并检查了SQL

。

从最初的代码：

  ALTER TABLE [DBO] [ChildToParentMapping] ADD CONSTRAINT [FK_dbo。 ChildToParentMapping_dbo.Children_ChildId]外键（[childID的]）ON DELETE CASCADE 
参考文献[DBO]。[儿童]（[childID的]） 

和从第二个代码：

  ALTER TABLE [DBO] [ChildToParentMapping] ADD CONSTRAINT [FK_dbo。 ChildToParentMapping_dbo.Children_ParentId]外键（[的ParentId]）ON DELETE CASCADE 
参考文献[DBO]。[儿童]（[childID的]） 

现在不是很好。的ParentId映射侵害儿童肯定不是我们想要的。

那么，第二个映射错了吗？并非如此，因为看的时候我删除了第一个发生了什么：

  ALTER TABLE [DBO] [ChildToParentMapping] ADD CONSTRAINT [FK_dbo。 .ChildToParentMapping_dbo.Parents_ParentId]外键（[的ParentId]）参考文献[DBO]。[家长]（[的ParentId]）ON DELETE CASCADE 
  

不知何故，有两个映射似乎把事情搞得一团糟。错误或不我不知道。

I have some code that saves a many to many relationship in code. It was working fine with Entity Framework 4.1 but after updating to Entity Framework 5, it's failing.

I'm getting the following error:

The INSERT statement conflicted with the FOREIGN KEY constraint "FK_WebUserFavouriteEvent_Event". The conflict occurred in database "MainEvents", table "dbo.Event", column 'Id'.

I'm using POCO entities with custom mappings. Standard field and many-to-one relationship mappings seem to be working fine.

UPDATE

Ok, so I've got SQL Profiler installed and the plot has thickened...

exec sp_executesql N'insert [dbo].[WebUserFavouriteEvent]([WebUserId], [EventId])
values (@0, @1)
',N'@0 int,@1 int',@0=1820,@1=14

Which means:

WebUserId = @0 = 1820
EventId = @1 = 14

The interesting thing is is that EF5 seems to have flipped the foreign keys around... the WebUserId should be 14 and the EventId should be 1820, not the other way around like it is now.

I reviewed the mapping code and I'm 99% I've set it all up correctly. See Entity Framework Fluent API - Relationships MSDN article for more information.

NOTE: I have also found that this isn't restricted to saving either, SELECTs are also broken.

Here's all the relevant code:

Service Layer

public void AddFavEvent(WebUser webUser, Event @event)
{
    webUser.FavouriteEvents.Add(@event);

    _webUserRepo.Update(webUser);
}

Repository

public void Update<T>(params T[] entities)
    where T : DbTable
{
    foreach (var entity in entities)
    {
        entity.UpdatedOn = DateTime.UtcNow;
    }

    _dbContext.SaveChanges();
}

NOTE: I'm using a 1 DataContext per request approach, so webUser and @event would have been loaded from the same context as the one in the _webUserRepo.

Entities (don't worry about DbTable stuff)

public class Event : DbTable
{
    //BLAH
    public virtual ICollection<WebUser> FavouriteOf { get; set; }
    //BLAH
}

public class WebUser : DbTable
{
    //BLAH
    public virtual ICollection<Event> FavouriteEvents { get; set; }
    //BLAH
}

Mappings

public class EventMapping : DbTableMapping<Event>
{
    public EventMapping()
    {
        ToTable("Event");
        //BLAH
        HasMany(x => x.FavouriteOf)
            .WithMany(x => x.FavouriteEvents)
            .Map(x =>
                     {
                         x.MapLeftKey("EventId");
                         x.MapRightKey("WebUserId");
                         x.ToTable("WebUserFavouriteEvent");
                     });
    }
}

public class WebUserMapping : DbTableMapping<WebUser>
{
    public WebUserMapping ()
    {
        HasMany(x => x.FavouriteEvents)
            .WithMany(x => x.FavouriteOf)
            .Map(m =>
                     {
                         m.MapLeftKey("WebUserId");
                         m.MapRightKey("EventId");
                         m.ToTable("WebUserFavouriteEvent");
                     });
    }
}

解决方案

Looking at this I suspect that the problem might be caused by the fact that you map the same relationship twice. And you map it in different order.

I made a simple test where I first mapped the relationship once:

    class Program
{
    static void Main(string[] args)
    {
        Database.SetInitializer(new DropCreateDatabaseAlways<Context>());
        var p = new Parent();
        var c = new Child();
        using (var db = new Context())
        {
            db.Parents.Add(new Parent());
            db.Parents.Add(p);

            db.Children.Add(c);
            db.SaveChanges();
        }

        using (var db = new Context())
        {
            var reloadedP = db.Parents.Find(p.ParentId);
            var reloadedC = db.Children.Find(c.ChildId);

            reloadedP.Children = new List<Child>();
            reloadedP.Children.Add(reloadedC);

            db.SaveChanges();
        }

        using (var db = new Context())
        {
            Console.WriteLine(db.Children.Count());
            Console.WriteLine(db.Children.Where(ch => ch.ChildId == c.ChildId).Select(ch => ch.Parents.Count).First());
            Console.WriteLine(db.Parents.Where(pa => pa.ParentId == p.ParentId).Select(pa => pa.Children.Count).First());
        }
    }
}

public class Parent
{
    public int ParentId { get; set; }
    public ICollection<Child> Children { get; set; }

}

public class Child
{
    public int ChildId { get; set; }
    public ICollection<Parent> Parents { get; set; }
}

public class Context : DbContext
{
    public Context() : base("data source=Mikael-PC;Integrated Security=SSPI;Initial Catalog=EFTest")
    {

    }

    public IDbSet<Child> Children { get; set; }
    public IDbSet<Parent> Parents { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Child>()
            .HasMany(x => x.Parents)
            .WithMany(x => x.Children)
            .Map(c =>
            {
                c.MapLeftKey("ChildId");
                c.MapRightKey("ParentId");
                c.ToTable("ChildToParentMapping"); 
            });

    }
}

And then I changed the OnModelCreating to be:

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Child>()
            .HasMany(x => x.Parents)
            .WithMany(x => x.Children)
            .Map(c =>
            {
                c.MapLeftKey("ChildId");
                c.MapRightKey("ParentId");
                c.ToTable("ChildToParentMapping"); 
            });

        modelBuilder.Entity<Parent>()
           .HasMany(x => x.Children)
           .WithMany(x => x.Parents)
           .Map(c =>
           {
               c.MapLeftKey("ParentId");
               c.MapRightKey("ChildId");
               c.ToTable("ChildToParentMapping");
           });
    }

What I found and suspected is that the first run generates this sql:

exec sp_executesql N'insert [dbo].[ChildToParentMapping]([ChildId], [ParentId])
values (@0, @1)
',N'@0 int,@1 int',@0=1,@1=2

In constrast to the second which generates:

exec sp_executesql N'insert [dbo].[ChildToParentMapping]([ParentId], [ChildId])
values (@0, @1)
',N'@0 int,@1 int',@0=1,@1=2

You see the values flipped? Here it actually count the ChildId column as ParentId. Now this doesn't crash for me but I let EF create the database which means it probably just switch the column names and if I would look at the foreign keys they would be switched too. If you created the database manually that probably won't be the case.

So in short: You mappings aren't equal and I expect one of them to be used and that one is probably wrong. In earlier verions I guess EF picked them up in different order.

UPDATE: I got a bit curious about the foreign keys and checked the sql.

From the first code:

ALTER TABLE [dbo].[ChildToParentMapping] ADD CONSTRAINT [FK_dbo.ChildToParentMapping_dbo.Children_ChildId] FOREIGN KEY ([ChildId]) REFERENCES [dbo].[Children] ([ChildId]) ON DELETE CASCADE

And from the second code:

ALTER TABLE [dbo].[ChildToParentMapping] ADD CONSTRAINT [FK_dbo.ChildToParentMapping_dbo.Children_ParentId] FOREIGN KEY ([ParentId]) REFERENCES [dbo].[Children] ([ChildId]) ON DELETE CASCADE

Now that is not nice. ParentId mapped against Children is certainly not what we want.

So is the second mapping wrong? Not really because see what happend when I removed the first one:

ALTER TABLE [dbo].[ChildToParentMapping] ADD CONSTRAINT [FK_dbo.ChildToParentMapping_dbo.Parents_ParentId] FOREIGN KEY ([ParentId]) REFERENCES [dbo].[Parents] ([ParentId]) ON DELETE CASCADE

Somehow having two mappings seems to mess things up. Bug or not I don't know.

这篇关于许多一对多的关系，左右键后，实体框架5的升级翻转的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！