public Object UseService(Type type)
{
PHPRPC_InvocationHandler handler = new PHPRPC_InvocationHandler(this);
if (type.IsInterface)
{
return(DynamicProxy.NewInstance(AppDomain.CurrentDomain, new Type[] { type }, handler));
}
else
{
return(DynamicProxy.NewInstance(AppDomain.CurrentDomain, type.GetInterfaces(), handler));
}
}
public static TInterface CreateMock <TInterface>(bool autoRegisterToContainer = false) where TInterface : class
{
TInterface mock = DynamicProxy.NewInstance <TInterface>(new IInterceptor[] { new MockerInterceptor() }, new Type[] { typeof(IMockObject) }) as TInterface;
// Verifica se o mock deve ser registrado no container de injeção de dependencia.
if (autoRegisterToContainer == true)
{
IocFactory.Register(
Component.For <TInterface>().Instance(mock)
);
}
return(mock);
}
public Object UseService(Type[] interfaces)
{
PHPRPC_InvocationHandler handler = new PHPRPC_InvocationHandler(this);
return(DynamicProxy.NewInstance(AppDomain.CurrentDomain, interfaces, handler));
}
//private static object CreateInstance(Type interfaceType, ComponentData componentData, IEnumerable<Type> interceptorCollection, params object[] constructorParameters) {
private static object CreateInstance(Type interfaceType, ComponentData componentData, IRegistrationInfo registrationInfo, params object[] constructorParameters)
{
// Obtém o primeiro tipo concreto registrado para ser instanciado.
Type concreteType = componentData.ConcreteType;
// Obtém os construtores públicos da classe concreta.
ConstructorInfo[] constructorInfoCollection = concreteType.GetConstructors();
// Verifica se existe um construtor padrão (sem parâmetros).
bool hasDefaultContructor = constructorInfoCollection.Any(p => p.GetParameters().Length == 0);
List <object> interceptors = new List <object>();
if (registrationInfo != null && registrationInfo.InterceptorCollection.Any() == true)
{
foreach (Type interceptor in registrationInfo.InterceptorCollection)
{
// Cria uma instancia do interceptor.
object interceptorInstance = Activator.CreateInstance(interceptor);
interceptors.Add(interceptorInstance);
}
}
// Caso exista um construtor padrão e nenhum parâmetro tenha sido especificado, cria a instancia.
if (hasDefaultContructor == true && constructorParameters.Length == 0)
{
// Cria e retorna uma nova instancia do tipo concreto com o construtor padrão.
object instance = CreateInstance(registrationInfo, concreteType);
// Caso algum interceptor tenha sido especificado, utiliza um proxy.
return((registrationInfo.InterceptorCollection.Any() == false) ? instance : DynamicProxy.NewInstance(instance, interceptors.OfType <IInterceptor>().ToArray()));
}
// Caso não exista um construtor padrão, ou algum parâmetro tenha sido especificado.
if (constructorParameters.Length > 0)
{
// Armazena a lista de tipos dos parâmetros do construtor.
IEnumerable <Type> constructorParameterTypeCollection = constructorParameters.Select(p => p.GetType());
// Analisa todos os construtores disponíveis.
foreach (ConstructorInfo constructorInfo in constructorInfoCollection)
{
// Obtém os parâmetros do construtor.
ParameterInfo[] parameterInfoCollection = constructorInfo.GetParameters();
// Caso o construtor não possua a mesma quantidade de parâmetros que foram informados, passa para o próximo construtor.
if (constructorParameterTypeCollection.Count() != parameterInfoCollection.Count())
{
continue;
}
// Obtém a lista de tipos dos parâmetros.
IEnumerable <Type> parameterTypeCollection = parameterInfoCollection.Select(p => p.ParameterType);
IList <Type> matchedParameterList = new List <Type>();
int parameterCounter = 0;
// Percorre a lista de parâmetros encontrados no construtor.
foreach (Type parameterType in parameterTypeCollection)
{
// Percorre a lista de parâmetros informados para instanciar o tipo.
do
{
Type constructorParameterType = constructorParameterTypeCollection.ElementAt(parameterCounter);
parameterCounter++;
if (constructorParameterType == parameterType || (parameterType.IsInterface && parameterType.IsAssignableFrom(constructorParameterType) == true) || constructorParameterType.BaseType == parameterType)
{
matchedParameterList.Add(constructorParameterType);
break;
}
} while (parameterCounter < constructorParameterTypeCollection.Count());
}
// Caso as assinaturas dos parâmetros e do construtor sejam identicas, utiliza o construtor atual.
if (matchedParameterList.Count == parameterTypeCollection.Count())
{
object instance = CreateInstance(registrationInfo, concreteType, constructorParameters);
// Caso algum interceptor tenha sido especificado, utiliza um proxy.
return((registrationInfo.InterceptorCollection.Any() == false) ? instance : DynamicProxy.NewInstance(instance, interceptors.OfType <IInterceptor>().ToArray()));
}
}
}
IList <object> parameters = new List <object>();
// Analisa todos os construtores disponíveis.
foreach (ConstructorInfo constructorInfo in constructorInfoCollection)
{
// Obtém os parâmetros do construtor.
ParameterInfo[] parameterInfoCollection = constructorInfo.GetParameters();
// Verifica cada parâmetro do construtor.
foreach (ParameterInfo parameterInfo in parameterInfoCollection)
{
Type parameterType = parameterInfo.ParameterType;
// Verifica se não é um tipo base do .NET.
if (parameterType.FullName.StartsWith("System.") == false)
{
// Tenta localizar alguma interface registrada que seja do mesmo tipo do construtor.
IRegistrationInfo parameterRegistrationInfo = RegistrationInfoCollection.FirstOrDefault(p => p.InterfaceType.IsAssignableFrom(parameterType) == true);
// Caso nenhum tipo tenha sido encontrado, passa para o próximo parâmetro.
if (parameterRegistrationInfo == null)
{
continue;
}
ComponentData dependencyData = parameterRegistrationInfo.ComponentDataCollection.FirstOrDefault(p => p.ConcreteType != null && (p.ConcreteType == parameterType || parameterType.IsAssignableFrom(p.ConcreteType)));
if (dependencyData == null)
{
continue;
}
// Adiciona uma instancia do tipo encontrado na lista de parâmetros do construtor.
parameters.Add(CreateInstance(interfaceType, dependencyData, registrationInfo));
}
}
// Verifica se a quantidade de parâmetros esta de acordo com a quantidade de objetos disponíveis.
if (parameters.Count == parameterInfoCollection.Length)
{
object instance = CreateInstance(registrationInfo, concreteType, parameters.ToArray());
// Caso algum interceptor tenha sido especificado, utiliza um proxy.
return((registrationInfo.InterceptorCollection.Any() == false) ? instance : DynamicProxy.NewInstance(instance, interceptors.OfType <IInterceptor>().ToArray()));
}
}
throw new InvalidOperationException("Could not find any constructor matching the specified parameters.");
}