Category: Entity Framework Code First

This is the seventh post in a series of posts about bringing the features that were present in Entity Framework pre-Core into EF Core. The others are:

• Part 1: Introduction, Find, Getting an Entity’s Id Programmatically, Reload, Local, Evict

• Part 2: Explicit Loading

• Part 3: Validations

• Part 4: Conventions

• Part 5: Getting the SQL for a Query

• Part 6: Lazy Loading

This time I’m going to cover automatic entity configuration in mapping classes, that is, outside of the DbContext.OnModelCreating method. If you remember, Entity Framework Code First supported having classes inheriting from EntityTypeConfiguration in the same assembly as the context, and these classes would be loaded automatically. This made it much simpler to add new mapping classes to a project without touching the context.

This functionality hasn’t been ported to Entity Framework Core yet, but it is being developed for the next version, and is tracked by ticket 2805. My implementation finds mapping classes in the same assembly as the context automatically, or it can load configuration explicitly from a mapping class. Here is my contract for the mapping class:

public interface IEntityTypeConfiguration<T> where T : class
{
    void Configure(EntityTypeBuilder<T> entityTypeBuilder);
}

As you can see, this needs to be implemented in a concrete generic class and bound to a specific entity type.

The actual implementation goes like this:

public static class EntityTypeConfigurationExtensions
{
    private static readonly MethodInfo entityMethod = typeof(ModelBuilder).GetTypeInfo().GetMethods().Single(x => (x.Name == "Entity") && (x.IsGenericMethod == true) && (x.GetParameters().Length == 0));

    private static Type FindEntityType(Type type)
    {
        var interfaceType = type.GetInterfaces().First(x => (x.GetTypeInfo().IsGenericType == true) && (x.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration<>)));
        return interfaceType.GetGenericArguments().First();
    }

    private static readonly Dictionary<Assembly, IEnumerable<Type>> typesPerAssembly = new Dictionary<Assembly, IEnumerable<Type>>();

    public static ModelBuilder ApplyConfiguration<T>(this ModelBuilder modelBuilder, IEntityTypeConfiguration<T> configuration) where T : class
    {
        var entityType = FindEntityType(configuration.GetType());

        dynamic entityTypeBuilder = entityMethod
            .MakeGenericMethod(entityType)
            .Invoke(modelBuilder, new object[0]);

        configuration.Configure(entityTypeBuilder);

        return modelBuilder;
    }

    public static ModelBuilder UseEntityTypeConfiguration(this ModelBuilder modelBuilder)
    {
        IEnumerable<Type> configurationTypes;
        var asm = Assembly.GetEntryAssembly();

        if (typesPerAssembly.TryGetValue(asm, out configurationTypes) == false)
        {
            typesPerAssembly[asm] = configurationTypes = asm
                .GetExportedTypes()
                .Where(x => (x.GetTypeInfo().IsClass == true) && (x.GetTypeInfo().IsAbstract == false) && (x.GetInterfaces().Any(y => (y.GetTypeInfo().IsGenericType == true) && (y.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration<>)))));
        }

        var configurations = configurationTypes.Select(x => Activator.CreateInstance(x));

        foreach (dynamic configuration in configurations)
        {
            ApplyConfiguration(modelBuilder, configuration);
        }

        return modelBuilder;
    }
}

You can see that it uses some dynamic magic to make things simpler, otherwise we’d need to have even more reflection. Dynamics take care of these things quite nicely.

The code essentially looks at the entry assembly and finds all non-abstract public types that implement IEntityTypeConfiguration<T>. For each of those, it creates an instance, extracts the template argument and creates an EntityTypeBuilder<T> from calling the Entity<T> method of the ModelBuilder class and calls the IEntityTypeConfiguration<T>.Configure method of the instantiated mapping class passing it the EntityTypeBuilder<T> which allows it to supply mapping configuration for the mapped entity (T).

We need to explicitly call this extension inside DbContext.OnModelCreating:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.UseEntityTypeConfiguration();
    base.OnModelCreating(modelBuilder);
}

And it takes care of everything for us. Or, if we want to load a single mapping class explicitly, we can also do so:

modelBuilder.UseEntityTypeConfiguration<MyEntityTypeConfiguration>();

Finally, a simple mapping class might be:

public class MyEntityTypeConfiguration : IEntityTypeConfiguration<MyEntity>
{
    public void Configure(EntityTypeBuilder<MyEntity> entityTypeBuilder)
    {
        entityTypeBuilder.ToTable("MyEntity");
        entityTypeBuilder.Property(x => x.MyEntityId).HasColumnName("Id");
    }
}

In case you’re interested, this feature is similar to the one being implemented for .NET Core, except that it doesn’t find mapping classes automatically. The IEntityTypeConfiguration<T> interface is exactly the same.

Updated: with EF Core 1.1 and 2.0.

Here’s a brief summary of some of the features that were present in previous versions of Entity Framework (6.x) and were excluded (or are not yet implemented) in Entity Framework Core 2.0:

Please let me know if you think I missed something!

See Microsof’t comparison of Core and pre-Core versions here: https://docs.microsoft.com/en-us/ef/efcore-and-ef6/features.

For the most up to date roadmap, please consult the EF Core roadmap: https://github.com/aspnet/EntityFramework/wiki/Roadmap.

Also, do check out the Entity Framework issue tracker: https://github.com/aspnet/EntityFramework/issues