public static IDependencyResolver CreateDependencyResolver(IAppDomainHelper[] appDomainHelpers)
{
var depResolverTypeName = ConfigurationManager.AppSettings["BoC.IoC.ResolverTypeName"];
Type depresolverType = null;
if (depResolverTypeName != null)
{
depresolverType = Type.GetType(depResolverTypeName, false);
}
if (depresolverType == null && appDomainHelpers != null)
{
depresolverType = appDomainHelpers.SelectMany(a =>
a.GetTypes(t => typeof(IDependencyResolver).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && t.IsPublic))
.FirstOrDefault();
}
return depresolverType == null ? null : Activator.CreateInstance(depresolverType) as IDependencyResolver;
}
private static IContainerInitializer CreateTask(IDependencyResolver dependencyResolver, Type type, IAppDomainHelper[] appDomainHelpers)
{
var constructor = type.GetConstructors().First();
var parameters = constructor.GetParameters();
if (!parameters.Any())
return Activator.CreateInstance(type) as IContainerInitializer;
var parameterValues = new object[parameters.Length];
for (var i=0;i<parameters.Length;i++)
{
if (typeof (IDependencyResolver).IsAssignableFrom(parameters[i].ParameterType))
parameterValues[i] = dependencyResolver;
else if (parameters[i].ParameterType == typeof (IAppDomainHelper[]))
parameterValues[i] = appDomainHelpers;
else
{
parameterValues[i] = Activator.CreateInstance(parameters[i].ParameterType);
}
}
return constructor.Invoke(parameterValues) as IContainerInitializer;
}
public RegisterBackgroundTasks(IDependencyResolver dependencyResolver, IAppDomainHelper[] appDomainHelpers)
{
this.dependencyResolver = dependencyResolver;
this.appDomainHelpers = appDomainHelpers;
}
public AutoDb4oRepositoryGenerator(IDependencyResolver dependencyResolver, IAppDomainHelper[] appDomainHelpers)
{
this._dependencyResolver = dependencyResolver;
_appDomainHelpers = appDomainHelpers;
}
public AutoRegisterModelServices(IDependencyResolver dependencyResolver, IAppDomainHelper[] appDomainHelpers)
{
this.dependencyResolver = dependencyResolver;
this.appDomainHelpers = appDomainHelpers;
}
public AutoUmbracoRepositoryGenerator(IDependencyResolver dependencyResolver, IAppDomainHelper[] appDomainHelpers)
{
_dependencyResolver = dependencyResolver;
_appDomainHelpers = appDomainHelpers;
}
public AutoNhibernateRepositoryGenerator(IDependencyResolver dependencyResolver, IAppDomainHelper[] appDomainHelpers)
{
this.dependencyResolver = dependencyResolver;
_appDomainHelpers = appDomainHelpers;
}
public static void GenerateRepositories(IDependencyResolver dependencyResolver, Type defaultBaseType, Type[] constructorParams, IAppDomainHelper[] appDomainHelpers)
{
const string idPropertyName = "Id";
var interfaceToFind = typeof(IRepository<>);
var isbasetype = new Func<Type, bool>(basetype =>
basetype.IsGenericType &&
basetype.GetGenericTypeDefinition() == typeof (BaseEntity<>));
//below should work fine for all situations :)
ModuleBuilder mb = null;
var types = appDomainHelpers.SelectMany(
helper => helper.GetTypes(t => true)).ToArray();
var entities = from t in types
where t.IsClass
&& !t.IsAbstract
&& typeof (IBaseEntity).IsAssignableFrom(t)
&& !isbasetype(t)
select t;
int typeNum = 0;
foreach (var type in entities.ToArray())
{
var interfaceType = interfaceToFind.MakeGenericType(new Type[] { type });
if (interfaceType == null)
{
continue;
}
var toFind = (from i in types
where i.IsInterface &&
interfaceType.IsAssignableFrom(i)
select i).FirstOrDefault() ?? interfaceType;
if (dependencyResolver.IsRegistered(toFind))
{
//this repository is already registered, if you have multiple repositories implementing the same interface,
//you'll have to register the correct one 'by hand'
continue;
}
var repo = (from r in types
where !r.IsInterface &&
toFind.IsAssignableFrom(r)
select r
).FirstOrDefault();
if (repo == null)
{
if (mb == null)
mb = GetRepositoriesModuleBuilder();
var name = "DynamicGeneratedRepository" + typeNum++;
var baseType = defaultBaseType.MakeGenericType(new Type[] { type });
var baseConstructor = baseType.GetConstructor(constructorParams);
var tb = mb.DefineType(name, TypeAttributes.AutoLayout | TypeAttributes.Public,
baseType,
new Type[] {toFind});
var constructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard,
constructorParams);
for (int i = 1; i <= constructorParams.Length; i++)
{
constructor.DefineParameter(i, ParameterAttributes.None, "param" + i);
}
ILGenerator ilGenerator = constructor.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0); // Load "this"
for (int i = 1; i <= constructorParams.Length; i++)
{
ilGenerator.Emit(OpCodes.Ldarg, i);
}
ilGenerator.Emit(OpCodes.Call, baseConstructor); // Call the base constructor
ilGenerator.Emit(OpCodes.Ret);
try
{
repo = tb.CreateType();
}
catch (TypeLoadException exception)
{
throw new TypeLoadException("Error creating an automatic generated Repository for " + toFind, exception);
}
}
dependencyResolver.RegisterType(interfaceType, repo);
if (interfaceType != toFind)
dependencyResolver.RegisterType(toFind, repo);
}
}
public Bootstrapper(IDependencyResolver dependencyResolver, IAppDomainHelper[] appDomainHelpers)
{
this.dependencyResolver = dependencyResolver;
this.appDomainHelpers = appDomainHelpers;
}
public AppDomainHelperConfigLoader(IAppDomainHelper[] helpers)
{
_helpers = helpers;
}
private static void RunContainerInitializers(IDependencyResolver dependencyResolver, IAppDomainHelper[] appdomainHelpers)
{
if (appdomainHelpers == null || appdomainHelpers.Any() )
{
var helper = AppDomainHelper.CreateDefault();
appdomainHelpers = new[] {helper};
}
if (!dependencyResolver.IsRegistered(typeof (IAppDomainHelper)))
{
foreach (var helper in appdomainHelpers)
{
dependencyResolver.RegisterInstance<IAppDomainHelper>(helper);
}
}
var allTasks =
appdomainHelpers.SelectMany(helper => helper.GetTypes(
t => t.IsClass && !t.IsAbstract && typeof (IContainerInitializer).IsAssignableFrom(t)));
//run them:
var allTasksList = allTasks as IList<Type> ?? allTasks.ToList();
var nonbocHelpers = allTasksList.Where(t => t.Namespace != null && !t.Namespace.StartsWith("BoC."));
var bocHelpers = allTasksList.Where(t => t.Namespace != null && t.Namespace.StartsWith("BoC."));
//first user's tasks:
foreach (var type in nonbocHelpers)
{
var task = CreateTask(dependencyResolver, type, appdomainHelpers);
task.Execute();
}
//now ours:
foreach (var type in bocHelpers )
{
var task = CreateTask(dependencyResolver, type, appdomainHelpers);
task.Execute();
}
}
