Question

（EF4.1 - 4.0框架）

网络上的大多数代码示例都规定了实体框架的最佳实践;他们说在使用块中包装你对DBContext的使用，以确保无状态操作。即使如此，我还是得到了似乎是共享缓存的错误。

ERROR

ObjectStateManager中已存在具有相同键的对象。 ObjectStateManager无法跟踪具有相同对象的多个对象键。

环顾四周，当有人在多次调用中共享DBContext的全局实例时，会出现这种情况。

然而，我在第二次调用以下函数时收到此信息，该函数位于静态数据访问层服务类中。

public static void UpdateRollout(Rollout rollout)
        {

               using (ITAMEFContext db = new ITAMEFContext(ConnectionStrings.XYZConnectionString))
                {
                    db.Configuration.ProxyCreationEnabled = false;
                    db.Configuration.LazyLoadingEnabled = false;

                    FixUp(rollout);


                    db.Rollouts.Attach(rollout);
                    db.Entry(rollout).State = System.Data.EntityState.Modified;

                    db.SaveChanges();

                    //db.Entry(rollout).State = System.Data.EntityState.Detached;

                }

}



private static void FixUp(Rollout rollout)
        {
            // ensure manual fixup of foreign keys
            if (rollout.RolloutState != null)
                rollout.FK_RolloutState_ID = rollout.RolloutState.ID;
            if (rollout.Lead != null)
                rollout.RolloutLead_FK_User_ID = rollout.Lead.ID;
        }

EFContext是通过引用edmx模型的EF 4.x DBContext Fluent Generator生成的。

edmx model picture

看起来像这样。

public partial class ITAMEFContext : DbContext
{
    static ITAMEFContext()
    {
        Database.SetInitializer<ITAMEFContext>(null);
    }

    public ITAMEFContext() : base("name=ITAMEFContext")
    {
        this.Configuration.LazyLoadingEnabled = false;

    }

    public ITAMEFContext(string nameOrConnectionString) : base(nameOrConnectionString)
    {

    }

    public ITAMEFContext(string nameOrConnectionString, DbCompiledModel model) : base(nameOrConnectionString, model)
    {

    }

    public ITAMEFContext(DbConnection existingConnection, bool contextOwnsConnection) : base(existingConnection, contextOwnsConnection)
    {

    }

    public ITAMEFContext(DbConnection existingConnection, DbCompiledModel model, bool contextOwnsConnection) : base(existingConnection, model, contextOwnsConnection)
    {

    }
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Conventions.Remove<IncludeMetadataConvention>();
        modelBuilder.Configurations.Add(new Asset_Mapping());
        modelBuilder.Configurations.Add(new AssetAllocation_Mapping());
        modelBuilder.Configurations.Add(new AssetAssignee_Mapping());
        modelBuilder.Configurations.Add(new AssetAssigneeType_Mapping());
        modelBuilder.Configurations.Add(new AssetDeAllocation_Mapping());
        modelBuilder.Configurations.Add(new AssetState_Mapping());
        modelBuilder.Configurations.Add(new AssetType_Mapping());
        modelBuilder.Configurations.Add(new Department_Mapping());
        modelBuilder.Configurations.Add(new Location_Mapping());
        modelBuilder.Configurations.Add(new ManagementGroup_Mapping());
        modelBuilder.Configurations.Add(new Role_Mapping());
        modelBuilder.Configurations.Add(new Rollout_Mapping());
        modelBuilder.Configurations.Add(new RolloutState_Mapping());
        modelBuilder.Configurations.Add(new ServiceArea_Mapping());
        modelBuilder.Configurations.Add(new Software_Mapping());
        modelBuilder.Configurations.Add(new SoftwareType_Mapping());
        modelBuilder.Configurations.Add(new SubTeam_Mapping());
        modelBuilder.Configurations.Add(new sys_UserLock_Mapping());
        modelBuilder.Configurations.Add(new Team_Mapping());
        modelBuilder.Configurations.Add(new User_Mapping());
        modelBuilder.Configurations.Add(new WorkingMethod_Mapping());
    }

    public DbSet<Asset> Assets { get; set; }
    public DbSet<AssetAllocation> AssetAllocations { get; set; }
    public DbSet<AssetAssignee> AssetAssignees { get; set; }
    public DbSet<AssetAssigneeType> AssetAssigneeTypes { get; set; }
    public DbSet<AssetDeAllocation> AssetDeAllocations { get; set; }
    public DbSet<AssetState> AssetStates { get; set; }
    public DbSet<AssetType> AssetTypes { get; set; }
    public DbSet<Location> Locations { get; set; }
    public DbSet<Department> Departments { get; set; }
    public DbSet<ManagementGroup> ManagementGroup { get; set; }
    public DbSet<Role> Roles { get; set; }
    public DbSet<ServiceArea> ServiceAreas { get; set; }
    public DbSet<SubTeam> SubTeams { get; set; }
    public DbSet<Team> Teams { get; set; }
    public DbSet<User> User { get; set; }
    public DbSet<WorkingMethod> WorkingMethods { get; set; }
    public DbSet<Rollout> Rollouts { get; set; }
    public DbSet<RolloutState> RolloutStates { get; set; }
    public DbSet<Software> Softwares { get; set; }
    public DbSet<SoftwareType> SoftwareTypes { get; set; }
    public DbSet<sys_UserLock> sys_UserLock { get; set; }
}

我希望能够根据需要多次从我的BL层调用UpdateRollout。 UI将需要保留POCO Rollout实体图，该图作为先前获取的List的一部分返回。

推出和所有其他实体都是纯POCO，不需要上下文跟踪。

我读到，一旦使用块处理了ITAMEFContext，任何上下文缓存/跟踪都会被删除。但是，在同一个应用程序域中，似乎有某种全局缓存支撑着DBContext的任何实例？我必须诚实地说，到目前为止EF似乎比使用好的旧存储过程分层应用程序要多得多。

POCO。

public partial class Rollout
{
    public Rollout()
    {
        this.AssetAssignees = new HashSet<AssetAssignee>();
    }

    public int ID { get; set; }
    public string Name { get; set; }
    public int RolloutLead_FK_User_ID { get; set; }
    public string EmailContacts { get; set; }
    public System.DateTime Schedule { get; set; }
    public int FK_RolloutState_ID { get; set; }
    public Nullable<int> NotificationDays { get; set; }
    public string Notes { get; set; }

    public virtual ICollection<AssetAssignee> AssetAssignees { get; set; }
    public virtual User Lead { get; set; }
    public virtual RolloutState RolloutState { get; set; }
}

编辑：

映射。

 internal partial class Rollout_Mapping : EntityTypeConfiguration<Rollout>
{
    public Rollout_Mapping()
    {                   
        this.HasKey(t => t.ID);     
        this.ToTable("Rollout");
        this.Property(t => t.ID).HasColumnName("ID");
        this.Property(t => t.Name).HasColumnName("Name").IsRequired().HasMaxLength(50);
        this.Property(t => t.RolloutLead_FK_User_ID).HasColumnName("RolloutLead_FK_User_ID");
        this.Property(t => t.EmailContacts).HasColumnName("EmailContacts").HasMaxLength(500);
        this.Property(t => t.Schedule).HasColumnName("Schedule");
        this.Property(t => t.FK_RolloutState_ID).HasColumnName("FK_RolloutState_ID");
        this.Property(t => t.NotificationDays).HasColumnName("NotificationDays");
        this.Property(t => t.Notes).HasColumnName("Notes");
        this.HasRequired(t => t.Lead).WithMany(t => t.Rollouts).HasForeignKey(d => d.RolloutLead_FK_User_ID);
        this.HasRequired(t => t.RolloutState).WithMany(t => t.Rollouts).HasForeignKey(d => d.FK_RolloutState_ID);
    }
}

Answer 1

我遇到了一个非常类似的问题，和你一样，我认为这是导致问题的某种全局缓存。

我的用例是：

使用新的DbContext，在我的数据库上设置一些测试数据然后处理DbContet
对我的应用程序运行系统测试
将数据库重置为基线状态（我在EF之外执行此操作）
从步骤1开始重复进行下一次系统测试

第一次测试时一切运行正常，但是在第二次测试时我得到了重复键错误。

这让我感到困惑了一段时间，直到我意识到我用来构建我的一些测试数据实体的工厂方法将它们创建为静态对象;第二次通过循环，一旦我将这些静态实体添加到上下文中，就会重新添加这些实体的完整对象图，所以当我后来添加其他实体时，它们已经存在。

这是一个简化的例子......

循环1：

创建对象A（静态）。保存更改[数据库现在包含A]
创建与对象A有关系的对象B（非静态）。保存更改[数据库现在包含A和B]
重置数据库[数据库现在不包含任何内容]

循环2：

创建对象A（静态，因此实际上没有重新创建。仍包含对B的引用，即使这不在数据库中）。保存更改[数据库现在包含A和B]
创建对象B（非静态）。保存更改。 [繁荣！重复键，因为B已经在数据库中]

解决方案： 我更改了工厂方法，以便我的实体都不是静态的。问题解决了。

Answer 2

编辑 - 我改写了我的回答。两点。

1：我发现这篇关于EF DbContext生命周期的文章（它引用了ObjectContext，但同样的规则适用）： http://blogs.msdn.com/b/alexj/archive/2009/05/07/tip-18-how-to-decide-on-a-lifetime-for-your-objectcontext.aspx

请注意，DbContext不是线程安全的。由于您使用的是静态方法，因此可能会遇到线程问题。在您需要的地方创建DbContext而不是在静态类中创建它可能是值得的。

2：理想情况下，您在DbCntext的同一个实例中进行读写。 “Disconnected”仅表示您的实体在使用它们时处于内存中，而DbContext正在跟踪您所做的更改。

我们使用更像这样的方法（伪代码）：

 public class RolloutManager {
   ...
   // If you just update state and you have no input from somewhere else, you can just  
   // read and write in the same method
   public void UpdateRolloutState() {
       using( var db = new MyDBContext() {
            var stuffToUpdate = db.Rollouts.Where(....).ToList();
            foreach(var stuff in StuffToUpdate){
                stuff.PropertyToUpdate = ....;
            }
            db.SaveChanges();
        }
   }

   // If you have inputs, pass them in (using a different object normally, such as a wcf 
   //contract or viewmodel), read them up from the db, update the db entities and save
   public void UpdateRolloutState(IEnumerable<InputRollout> stuffToUpdate) {
       using( var db = new MyDBContext() {
            foreach(var stuff in StuffToUpdate){
                var dbRollout = db.Rollouts.Find(stuff.Id);
                // copy properties you want to update
            }
            db.SaveChanges();
        }
   }

我希望这会有所帮助 - 它可能不是解决方案，但它可能会指向您找到一个。

实体框架DBContext全局缓存？

2 个答案: