public static Object CreateInstance(Type type, params object[] args)
{
var ctorCount = 0;
if (args != null)
{
ctorCount = args.Length;
}
var key = type.FullName + "." + ctorCount.ToString();
if (CacheMap.ContainsKey(key))
{
return(CacheMap[key].Invoke(args));
}
else
{
var ctor = type.GetConstructors()[ctorCount];
ObjectActivator <Object> createdActivator = GetActivator <Object>(ctor);
CacheMap.AddOrUpdate(key, createdActivator, (k, oldValue) => createdActivator);
return(createdActivator.Invoke(args));
}
}
public void CreateInstance_Expression()
{
ConstructorInfo ctor = typeof(Foo).GetConstructors().First();
ObjectActivator <Foo> createdActivator = GetActivator <Foo>(ctor);
Foo variable = null;
for (int i = 0; i < N; ++i)
{
variable = createdActivator.Invoke();
}
}
public object Resolve(DependencyContainer container, Stack <Type> stack)
{
if (resolvedObject != null)
{
return(resolvedObject);
}
var parameters = ResolveParameters(container, stack);
var obj = objectActivator.Invoke(parameters);
if (isSharedInstance)
{
resolvedObject = obj;
}
return(obj);
}
/*
* Activator.CreateInstance: 8.74 sec
* Linq Expressions: 0.104 sec
*/
public static T GetActivator <T>(Type type, int posCtor = 0)
{
ConstructorInfo ctor = type.GetConstructors().Skip(posCtor).First();
Type dType = ctor.DeclaringType;
ParameterInfo[] paramsInfo = ctor.GetParameters();
// Criar um único parâmetro do tipo type []
ParameterExpression param =
Expression.Parameter(typeof(object[]), "args");
Expression[] argsExp =
new Expression[paramsInfo.Length];
// Escolha cada arg da matriz params e crie uma expressão digitada deles
for (int i = 0; i < paramsInfo.Length; i++)
{
Expression index = Expression.Constant(i);
Type paramType = paramsInfo[i].ParameterType;
Expression paramAccessorExp =
Expression.ArrayIndex(param, index);
Expression paramCastExp =
Expression.Convert(paramAccessorExp, paramType);
argsExp[i] = paramCastExp;
}
// Faça um NewExpression que chame o ctor com os args que acabamos de criar
NewExpression newExp = Expression.New(ctor, argsExp);
// Crie um lambda com Expressão New como corpo e nosso objeto de parâmetro[] como arg
LambdaExpression lambda =
Expression.Lambda(typeof(ObjectActivator <T>), newExp, param);
// Compile-o
ObjectActivator <T> compiled = (ObjectActivator <T>)lambda.Compile();
return(compiled.Invoke());
}
public object Invoke(object instance, object[] args)
{
Debug.Assert(instance == null);
return(_objActivator.Invoke(args));
}
