Entity Framework: come memorizzare nella cache e condividere oggetti di sola lettura

Penso che la chiave di questa domanda sia esattamente l'eccezione:

Un oggetto entità non può essere referenziato da più istanze di IEntityChangeTracker.

Mi è venuto in mente che forse questa eccezione è Entity Framework che lamenta che un'istanza di un oggetto è stata modificata in più DbContexts anziché essere semplicemente referenziata da oggetti in più DbContexts . La mia teoria era basata sul fatto che le classi POCO generate hanno proprietà di navigazione FK inverse e che Entity Framework tenterebbe naturalmente di correggere queste proprietà di navigazione inversa come parte del processo di collegamento del grafo delle entità a DbContext (vedere una descrizione del processo di fix-up )

Per testare questa teoria ho creato un semplice progetto di test in cui ho potuto abilitare e disabilitare le proprietà di navigazione inversa. Con mia grande gioia ho scoperto che la teoria era corretta e che EF è abbastanza contento che gli oggetti vengano referenziati più volte fintanto che gli oggetti stessi non cambiano - e questo include le proprietà di navigazione modificate dal processo di correzione .

Quindi la risposta alla domanda è semplicemente seguire 2 regole: -

• Assicurarsi che gli oggetti dati statici non vengano mai modificati (idealmente non dovrebbero avere proprietà di setter pubblico) e
• Non includere alcuna proprietà di navigazione inversa FK che rimandi alle classi di riferimento. Per gli utenti del Reverse POCO Generator ho fatto un suggerimento a Simon Hughes (l'autore) di aggiungere un miglioramento rendendo questa un'opzione di configurazione.

Ho incluso le classi di test qui sotto:

class Program
{
    static void Main(string[] args)
    {
        ConcurrentDictionary<int,ClassA> theCache = null;

        try
        {
            using(var ctx = new MyDbContext())
            {
                var classAs = ctx.ClassAs
                    .Include(a => a.ClassAType)
                    .ToList();

                theCache = new ConcurrentDictionary<int,ClassA>(classAs.ToDictionary(a => a.ID));
            }

            // take 2 instances of ClassA that refer to the same ClassAType
            // and load them into separate DbContexts   
            var classA1 = theCache[1];
            var classA2 = theCache[2];

            var ctx1 = new MyDbContext();
            ctx1.ClassAs.Attach(classA1);

            var ctx2 = new MyDbContext();
            ctx2.ClassAs.Attach(classA2);

            // When ClassAType has a reverse FK navigation property to
            // ClassA we will not reach this line!    

            WriteDetails(classA1);
            WriteDetails(classA2);

            classA1.Name = "Updated";
            classA2.Name = "Updated";

            WriteDetails(classA1);
            WriteDetails(classA2);
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        System.Console.WriteLine("End of test");
    }

    static void WriteDetails(ClassA classA)
    {
        Console.WriteLine(String.Format("ID={0} Name={1} TypeName={2}", 
            classA.ID, classA.Name, classA.ClassAType.Name));
    }
}

public class ClassA
{
    public int ID { get; set; }
    public string ClassATypeCode { get; set; }
    public string Name { get; set; }

    //Navigation properties
    public virtual ClassAType ClassAType { get; set; }
}

public class ClassAConfiguration  : System.Data.Entity.ModelConfiguration.EntityTypeConfiguration<ClassA>
    {
    public ClassAConfiguration()
        : this("dbo")
    {
    }

    public ClassAConfiguration(string schema)
    {
        ToTable("TEST_ClassA", schema);
        HasKey(x => x.ID);

        Property(x => x.ID).HasColumnName(@"ID").IsRequired().HasColumnType("int").HasDatabaseGeneratedOption(System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity);
        Property(x => x.Name).HasColumnName(@"Name").IsRequired().HasColumnType("varchar").HasMaxLength(50);
        Property(x => x.ClassATypeCode).HasColumnName(@"ClassATypeCode").IsRequired().HasColumnType("varchar").HasMaxLength(50);

        //HasRequired(a => a.ClassAType).WithMany(b => b.ClassAs).HasForeignKey(c => c.ClassATypeCode);
        HasRequired(a => a.ClassAType).WithMany().HasForeignKey(b=>b.ClassATypeCode);
    }
}

public class ClassAType
{
    public string Code { get; private set; }
    public string Name { get; private set; }
    public int Flags { get; private set; }


    // Reverse navigation
    //public virtual System.Collections.Generic.ICollection<ClassA> ClassAs { get; set; }
}

public class ClassATypeConfiguration  : System.Data.Entity.ModelConfiguration.EntityTypeConfiguration<ClassAType>
    {
    public ClassATypeConfiguration()
        : this("dbo")
    {
    }

    public ClassATypeConfiguration(string schema)
    {
        ToTable("TEST_ClassAType", schema);
        HasKey(x => x.Code);

        Property(x => x.Code).HasColumnName(@"Code").IsRequired().HasColumnType("varchar").HasMaxLength(12);
        Property(x => x.Name).HasColumnName(@"Name").IsRequired().HasColumnType("varchar").HasMaxLength(50);
        Property(x => x.Flags).HasColumnName(@"Flags").IsRequired().HasColumnType("int");

    }
}

public class MyDbContext : System.Data.Entity.DbContext
{
    public System.Data.Entity.DbSet<ClassA> ClassAs { get; set; }
    public System.Data.Entity.DbSet<ClassAType> ClassATypes { get; set; }

    static MyDbContext()
    {
        System.Data.Entity.Database.SetInitializer<MyDbContext>(null);
    }

    const string connectionString = @"Server=TESTDB; Database=TEST; Integrated Security=True;";

    public MyDbContext()
        : base(connectionString)
    {
    }

    protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Configurations.Add(new ClassAConfiguration());
        modelBuilder.Configurations.Add(new ClassATypeConfiguration());
    }
}