Entity Framework 5 table-per-type update, change sub type but keep same base type

I don't have a good answer, but I can think of four "solutions" that are really workarounds:

Don't use DBMS-computed values for your primary keys (if you already use natural keys, it's fine).
Use DBMS-computed surrogate keys.
Follow something like the state pattern.
Do some evil voodoo with the object state manager.

Update: There seems to be a popular consensus that trying isn't even worth it; most people thus simply use stored procedures instead to work around the problem.

Using natural keys

First, remember that the objects tracked by the EF are part of your DAL, not your domain model (regardless of whether you use POCOs or not). Some people don't need a domain model, but keep it in mind, as we can now think of these objects as representations of table records we manipulate in ways we wouldn't with domain objects.

Here, we use IDbSet.Remove to delete the records of the entity, then add new ones with the same primary key using IDbSet.Add, all in a single transaction. See the ChangeType method in the sample code below.

In theory, integrity is OK, and in theory, EF could detect what you're trying to do and optimize things. In practice, it currently doesn't (I profiled the SQL interface to verify this). The result is that it looks ugly (DELETE+INSERT instead of UPDATE), so if system beauty and performance are issues, it's probably a no-go. If you can take it, it's relatively straightforward.

Here is some sample code I used to test this (if you want to experiment, simply create a new console application, add a reference to the EntityFramework assembly, and paste the code).

A is the base class, X and Y are subclasses. We consider Id to be a natural key, so we can copy it in the subclasses copy constructors (here only implemented for Y). The code creates a database and seeds it with a record of type X. Then, it runs and changes its type to Y, obviously losing X-specific data in the process. The copy constructor is where you would transform data, or archive it if data loss is not part of the business process. The only piece of "interesting" code is the ChangeType method, the rest is boilerplate.

using System;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;
using System.Linq;

namespace EntitySubTypeChange {
    abstract class A {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Id { get; set; }
        public string Foo { get; set; }
        public override string ToString() {
            return string.Format("Type:\t{0}{3}Id:\t{1}{3}Foo:\t{2}{3}",
                this.GetType(), Id, Foo, Environment.NewLine);
        }
    }

    [Table("X")]
    class X : A {
        public string Bar { get; set; }
        public override string ToString() {
            return string.Format("{0}Bar:\t{1}{2}", base.ToString(), Bar, Environment.NewLine);
        }
    }

    [Table("Y")]
    class Y : A {
        public Y() {}
        public Y(A a) {
            this.Id = a.Id;
            this.Foo = a.Foo;
        }

        public string Baz { get; set; }
        public override string ToString() {
            return string.Format("{0}Baz:\t{1}{2}", base.ToString(), Baz, Environment.NewLine);
        }
    }

    class Program {
        static void Main(string[] args) {
            Display();
            ChangeType();
            Display();
        }

        static void Display() {
            using (var context = new Container())
                Console.WriteLine(context.A.First());
            Console.ReadKey();
        }

        static void ChangeType()
        {
            using (var context = new Container()) {
                context.A.Add(new Y(context.A.Remove(context.X.First())));
                context.SaveChanges();
            }
        }

        class Container : DbContext {
            public IDbSet<A> A { get; set; }
            public IDbSet<X> X { get; set; }
            public IDbSet<Y> Y { get; set; }
        }

        static Program() {
            Database.SetInitializer<Container>(new ContainerInitializer());
        }

        class ContainerInitializer : DropCreateDatabaseAlways<Container> {
            protected override void Seed(Container context) {
                context.A.Add(new X { Foo = "Base Value", Bar = "SubType X Value" });
                context.SaveChanges();
            }
        }
    }
}

Output:

Type:   EntitySubTypeChange.X
Id:     0
Foo:    Base Value
Bar:    SubType X Value

Type:   EntitySubTypeChange.Y
Id:     0
Foo:    Base Value
Baz:

Note: If you want an auto-generated natural key, you can't let EF ask the DBMS to compute it, or EF will prevent you from manipulating it the way you want (see below). In effect, EF treats all keys with computed values as surrogate keys, even though it still happily leaks them (the bad of both worlds).

Note: I annotate the subclasses with Table because you mentioned a TPT setup, but the problem is not actually related to TPT.

Using surrogate keys

If you consider a surrogate key to be truly internal, then it doesn't matter if it changes under your nose as long as you can still access your data the same way (using a secondary index for example).

Note: In practice, many people leak surrogate keys all around (domain model, service interface, ...). Don't do it.

If you take the previous sample, simply remove the DatabaseGenerated attribute and the assignment of the Id in the copy constructor of the subtypes.

Note: With its value generated by the DBMS, the Id property is completely ignored by EF and doesn't serve any real purpose other than being analyzed by the model builder to generate the Id column in the SQL schema. That and being leaked by bad programmers.

Output:

Type:   EntitySubTypeChange.X
Id:     1
Foo:    Base Value
Bar:    SubType X Value

Type:   EntitySubTypeChange.Y
Id:     2
Foo:    Base Value
Baz:

Using the state pattern (or similar)

This solution is probably what most people would consider the "proper solution", since you can't change the intrinsic type of an object in most object-oriented languages. This is the case for CTS-compliant languages, which includes C#.

The problem is that this pattern is properly used in a domain model, not in a DAL like one implemented with EF. I'm not saying it's impossible, you may be able to hack things up with complex types or TPH constructs to avoid the creation of an intermediary table, but most likely you'll be swimming up the river until you give up. Hopefully someone can prove me wrong though.

Note: You can decide that you want your relational model to look different, in which case you may bypass this problem altogether. It wouldn't be an answer to your question though.

Using internal EF voodoo

I've rather quickly looked around the reference documentation for DbContext, ObjectContext and ObjectStateManager, and I can't immediately find any way to change the type of an entity. If you have better luck than me, you may be able to use DTOs and DbPropertyValues to do your conversion.

Important note

With the first two workarounds, you'll likely hit a bunch of problems with navigational properties and foreign keys (because of the DELETE+INSERT operation). This would be a separate question.

Conclusion

EF is not that flexible when you do anything non-trivial, but it keeps improving. Hopefully this answer won't be relevant in the future. It's also possible that I'm not aware of an existing killer-feature that would make what you want possible, so don't make any decisions based on this answer.