How can I load all Entity Framework 4.1 entity configuration entities via reflection?

In my OnModelCreating method for my data context I currently am manually mapping all my entity configuration mapping classes manually, like:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Configurations.Add(new UserMap());
    // 20 or so mapping configuration below
}

I want to streamline this by using reflection, so I have the following code:

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // Find all En开发者_JS百科tityTypeConfiguration classes in the assembly
        foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
            foreach (Type t in asm.GetTypes())
                if (t.IsDerivedFromOpenGenericType(typeof(EntityTypeConfiguration<>)))
                    modelBuilder.Configurations.Add(Activator.CreateInstance(t));   
    }

the IsDerivedFromOpenGenericType is from this question and works properly.

The problem is this doesn't compile because Activator.CreateInstance(t) returns an object, but the model builder is expecting a System.Data.Entity.ModelConfiguration.ComplexTypeConfiguration<TComplexType>.

Normally when using the Activator class I would just cast the object as whatever I expect type t to be (or what I expect the class to take), but since this is using a generics I don't know of a way to do that.

Does anyone have any ideas?

I'm not sure why this information is so hard to find (at least it was for me), but there is a much simpler way to do it detailed here.

public class MyDbContext : DbContext
{
  protected override void OnModelCreating(DbModelBuilder modelBuilder)
  {
    modelBuilder.Configurations.AddFromAssembly(Assembly.GetAssembly(GetType())); //Current Assembly
    base.OnModelCreating(modelBuilder);
  }
}

I got this from Rowan Miller at Microsoft:

  protected override void OnModelCreating(DbModelBuilder modelBuilder)
  {

        var addMethod = typeof (ConfigurationRegistrar)
            .GetMethods()
            .Single(m =>
                    m.Name == "Add" &&
                    m.GetGenericArguments().Any(a => a.Name == "TEntityType"));

        var assemblies = AppDomain.CurrentDomain
            .GetAssemblies()
            .Where(a => a.GetName().Name != "EntityFramework");

        foreach (var assembly in assemblies)
        {
            var configTypes = assembly
                .GetTypes()
                .Where(t => t.BaseType != null &&
                            t.BaseType.IsGenericType &&
                            t.BaseType.GetGenericTypeDefinition() == typeof (EntityTypeConfiguration<>));

            foreach (var type in configTypes)
            {
                var entityType = type.BaseType.GetGenericArguments().Single();

                var entityConfig = assembly.CreateInstance(type.FullName);
                addMethod.MakeGenericMethod(entityType)
                    .Invoke(modelBuilder.Configurations, new[] {entityConfig});
            }
        }

        base.OnModelCreating(modelBuilder);
    }

I found a much better way of doing this using composition with MEF:

public class Album
{
    public int AlbumId { get; set; }
    public int GenreId { get; set; }
    public int ArtistId { get; set; }
    public string Title { get; set; }
    public decimal Price { get; set; }
    public string AlbumArtUrl { get; set; }
    public Genre Genre { get; set; }
    public Artist Artist { get; set; }
}

using System.Data.Entity.ModelConfiguration.Configuration;

namespace MvcMusicStore.Models
{
   public interface IEntityConfiguration
   {
       void AddConfiguration(ConfigurationRegistrar registrar);
   }
}

using System.ComponentModel.Composition;
using System.Data.Entity.ModelConfiguration;
using System.Data.Entity.ModelConfiguration.Configuration;

namespace MvcMusicStore.Models.TypeConfig
{
  [Export(typeof(IEntityConfiguration))]
  public class AlbumTypeConfiguration : EntityTypeConfiguration<Album>, IEntityConfiguration
  {
    public AlbumTypeConfiguration()
    {
        ToTable("Album");
    }

    public void AddConfiguration(ConfigurationRegistrar registrar)
    {
        registrar.Add(this);
    }
  }
}

using System.Collections.Generic;
using System.ComponentModel.Composition;

namespace MvcMusicStore.Models
{
  public class ContextConfiguration
  {
      [ImportMany(typeof(IEntityConfiguration))]
      public IEnumerable<IEntityConfiguration> Configurations { get; set; }
  }
}

 using System;
 using System.ComponentModel.Composition.Hosting;
 using System.Data.Entity;
 using System.Data.Entity.ModelConfiguration;
 using System.Data.Entity.ModelConfiguration.Configuration;
 using System.Linq;
 using System.Reflection;

 namespace MvcMusicStore.Models
 {
   public class MusicStoreEntities : DbContext
   {
    public DbSet<Album> Albums { get; set; }
    public DbSet<Genre> Genres { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
        var container = new CompositionContainer(catalog);
        var exports = container.GetExportedValues<IEntityConfiguration>();

        foreach (var entityConfiguration in exports)
        {
            entityConfiguration.AddConfiguration(modelBuilder.Configurations);
        }    
        base.OnModelCreating(modelBuilder);
    }
  }
}

credit: OdeToCode.com Composing Entity Framework Fluent Configurations

You have to use reflection here as well.

Get the Method with Type.GetMethod() and then create the generic version you need with MethodInfo.MakeGenericMethod():

Type tCmpxTypeConfig = typeof (EntityTypeConfiguration<>);
tCmpxTypeConfig = tCmpxTypeConfig.MakeGenericType(t);

modelBuilder.Configurations.GetType()
    .GetMethod("Add", new Type[] { tCmpxTypeConfig })
    .MakeGenericMethod(t)
    .Invoke(modelBuilder.Configurations, 
        new object[] { Activator.CreateInstance(t) });