/// <summary> /// Sets the Database initializer associated to the DbContext with the given value. /// </summary> /// <param name="contextType">The type of the DbContext for which we want to set the value of the Database initializer.</param> /// <param name="dbContextTypeReference">The reference to DbContext type (or typeof(DbContext)).</param> /// <param name="initializer">The initializer object.</param> public static void SetDbInitializer(Type contextType, Type dbContextTypeReference, object initializer) { // We need the context type and the reference to DbContext type to be not null to set the database initializer. if (contextType == null || dbContextTypeReference == null) { return; } // Here, we basically need to do this: Database.SetInitializer<typeof(ContextType)>(initializer); // Load typeof(Database) from the EntityFramework assembly. Type databaseType = DbContextUtilities.LoadTypeFromAssembly(dbContextTypeReference.Assembly, DbContextUtilities.DatabaseTypeName); if (databaseType != null) { // Get the method Database.SetInitializer<DbContext>(IDatabaseInitializer<DbContext>); Type databaseInitializerType = dbContextTypeReference.Assembly.GetType(DbContextUtilities.IDatabaseInitializerTypeName); if (databaseInitializerType != null && databaseInitializerType.IsGenericType) { databaseInitializerType = databaseInitializerType.MakeGenericType(new Type[] { dbContextTypeReference }); MethodInfo setInitializerMethod = databaseType.GetMethod("SetInitializer", new Type[] { databaseInitializerType }); if (setInitializerMethod != null && setInitializerMethod.IsGenericMethod) { // Add the DbContext generic parameter to the method. MethodInfo genericSetInitializerMethod = setInitializerMethod.MakeGenericMethod(new Type[] { contextType }); if (genericSetInitializerMethod != null) { // We found the right method. Now invoke it with the initializer parameter. genericSetInitializerMethod.Invoke(null, new object[] { initializer }); } } } } }
/// <summary> /// Checks if this type is assignable from typeof(DbContext). /// </summary> /// <param name="type">The type to check if it is a DbContext.</param> /// <returns><c>true</c> is the type is a DbContext, <c>false</c> otherwise.</returns> public static bool IsDbContext(this Type type) { // If we have a reference to typeof(DbContext), then check if type is assignable from it. if (DbContextUtilities._dbContextTypeReference != null) { return(DbContextUtilities._dbContextTypeReference.IsAssignableFrom(type)); } else { // If we don't have reference to typeof(DbContext), then compare the base types to see if one of them is the EntityFramework DbContext type. // If we find a match, we also find the DbContext type. So populate the _dbContextTypeReference with that value. Type t = DbContextUtilities.GetDbContextTypeReference(type); if (t != null) { return(true); } else { return(false); } } }
/// <summary> /// Finds the reference to System.Data.Entity.DbContext type given the contextType, if it exists. /// </summary> /// <param name="contextType">The context type from which the DbContext type reference is to be found</param> /// <returns>The reference to DbContext type.</returns> public static Type GetDbContextTypeReference(Type contextType) { if (DbContextUtilities._dbContextTypeReference == null) { // if contextType is an interface or a value type, then we know it is not a DbContext type. if (!contextType.IsInterface && !contextType.IsValueType) { Type t = contextType; // If the type if null or object, then it is not the DbContext type. // We need to check for null as well, since Walking an interface hierarchy does not lead to Object. while (t != null && t != typeof(object)) { if (DbContextUtilities.CompareWithSystemType(t, DbContextUtilities.DbContextTypeName)) { DbContextUtilities._dbContextTypeReference = t; break; } t = t.BaseType; } } } return(DbContextUtilities._dbContextTypeReference); }