/// <summary>
/// Converts the Scheduled Task COM representation to Business Entity
/// </summary>
/// <param name="task">COM Scheduled Task</param>
/// <returns>An instance of Scheduled Task</returns>
private static ScheduledTask TransformToTask(IRegisteredTask task)
{
ScheduledTask scheduledTask = new ScheduledTask();
scheduledTask.Name = task.Name;
scheduledTask.CurrentState = task.State.ToString();
scheduledTask.TaskPath = task.Path;
scheduledTask.NextRunTime = task.NextRunTime;
scheduledTask.LastRunTime = task.LastRunTime;
scheduledTask.LastRunResults = task.LastTaskResult.ToString();
ITaskDefinition definition = task.Definition;
ITaskSettings settings = definition.Settings;
scheduledTask.Priority = settings.Priority;
scheduledTask.Settings = new Settings();
scheduledTask.Settings.Enabled = settings.Enabled;
scheduledTask.Settings.Hidden = settings.Hidden;
IRegistrationInfo registrationInfo = definition.RegistrationInfo;
scheduledTask.Description = registrationInfo.Description;
scheduledTask.Author = registrationInfo.Author;
return(scheduledTask);
}
public void RegistrationInfo_RegisterInterface_Test()
{
IRegistrationInfo registrationInfo = Component.For <IConfigurationUtilityMock>();
Assert.IsNotNull(registrationInfo);
Assert.IsNotNull(registrationInfo.InterfaceType);
Assert.IsTrue(registrationInfo.ComponentDataCollection.Count() == 0);
}
public override void Init(IRegistrationInfo registration)
{
// TODO: Needs fixing doesnt it !? key hashcode ? or whatever should be used ? _key.GetType().Name ?
// Create key
_key = "#" + registration.Type.Name; // Fullname ?
if (registration.Key != null)
_key += "-" + registration.Key;
}
internal override void RemoveInvocationInfo(IRegistrationInfo registrationInfo)
{
if (InvocationInfo == null || InvocationInfo.RegistrationInfo != registrationInfo)
{
throw new InvalidOperationException($"The request is unaware of this subscriber: {registrationInfo.OwnerType.Name}.{registrationInfo.PropertyName}");
}
InvocationInfo = null;
}
public override void Init(IRegistrationInfo registration)
{
// TODO: Needs fixing - use Key.GetType().Name or Key.GetHashcode or something. Should be Unique - Use Guid ?
// Create key
_key = "#" + registration.Type.Name; // Fullname ?
if (registration.Key != null)
_key += "-" + registration.Key;
}
public void RegistrationInfo_RegisterMultipleTypesToInterface_Test()
{
IRegistrationInfo registrationInfo = Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.ImplementedBy <AnotherMock>();
Assert.IsNotNull(registrationInfo);
Assert.IsNotNull(registrationInfo.InterfaceType);
Assert.IsTrue(registrationInfo.ComponentDataCollection.Count() == 2);
}
internal sealed override void RemoveInvocationInfo(IRegistrationInfo registrationInfo)
{
var invocationInfo = _invocationInfos.FirstOrDefault(info => info.RegistrationInfo == registrationInfo);
if (invocationInfo == null)
{
throw new InvalidOperationException($"Request is unaware of this subscriber: {registrationInfo.OwnerType.Name}.{registrationInfo.PropertyName}");
}
_invocationInfos.Remove(invocationInfo);
}
public void RegistrationInfo_RegisterTypeAsSingleton_Test()
{
IRegistrationInfo registrationInfo = Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.IsSingleton();
Assert.IsNotNull(registrationInfo);
Assert.IsNotNull(registrationInfo.InterfaceType);
Assert.IsTrue(registrationInfo.ComponentDataCollection.Count() == 1);
Assert.IsTrue(registrationInfo.ComponentDataCollection.First().IsSingleton);
}
public override void Init(IRegistrationInfo key)
{
base.Init(key);
// Could check here if Type implements IDisposable ?
// Will it work checking the actual type ?
//if (_disposeOnEnd && !(key.Type is IDisposable))
//{
// throw new DynamoRegistrationException(key, "To use the Dispose On End feature the instance registered needs to implement IDisposable");
//}
}
public void RegistrationInfo_RegisterWithInterceptor_Test()
{
IRegistrationInfo registrationInfo = Component
.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>()
.Interceptor <LogInterceptor>();
Assert.IsNotNull(registrationInfo);
Assert.IsNotNull(registrationInfo.InterfaceType);
Assert.IsTrue(registrationInfo.ComponentDataCollection.Count() == 1);
}
public void RegistrationInfo_RegisterWithCustomName_Test()
{
string expectedName = "Banana";
IRegistrationInfo registrationInfo = Component.For <IConfigurationUtilityMock>()
.ImplementedBy <ConfigurationUtilityMock>(expectedName);
Assert.IsNotNull(registrationInfo);
Assert.IsNotNull(registrationInfo.InterfaceType);
Assert.IsTrue(registrationInfo.ComponentDataCollection.Count() == 1);
Assert.IsNotNull(registrationInfo.ComponentDataCollection.SingleOrDefault(p => expectedName.Equals(p.Name, StringComparison.InvariantCultureIgnoreCase)));
}
/// <summary>
/// Register a component within the IocFactory.
/// </summary>
/// <param name="componentRegistrationCollection">The component to be registered. Create with the Component.For method.</param>
/// <include file='Samples/IocFactory.xml' path='Docs/Members[@name="Register"]/*'/>
public static void Register(params IRegistration[] componentRegistrationCollection)
{
foreach (IRegistration componentRegistration in componentRegistrationCollection)
{
// Obtém todos os componentes a serem registrados.
IRegistrationInfo[] registrationInfoCollection = componentRegistration.Register();
foreach (IRegistrationInfo registrationInfo in registrationInfoCollection)
{
// Tenta localizar um componente para a interface recebida.
IRegistrationInfo registeredRegistrationInfo = RegistrationInfoCollection.FirstOrDefault(p => p.InterfaceType == registrationInfo.InterfaceType);
// Caso não exista nenhum componente do mesmo tipo, adiciona-o a lista de componentes registrados.
if (registeredRegistrationInfo == null)
{
RegistrationInfoCollection.Add(registrationInfo);
}
else
{
// Adiciona cada novo ComponentData.
foreach (ComponentData componentData in registrationInfo.ComponentDataCollection)
{
// Verifica se o componente já existe para o tipo registrado. Caso negativo, adiciona o componente.
if (registeredRegistrationInfo.ComponentDataCollection.Any(p => p.ConcreteType == componentData.ConcreteType) == false)
{
AbstractComponentInfo componentInfo = (AbstractComponentInfo)registeredRegistrationInfo;
// Adiciona o componente ao tipo.
componentInfo.AddComponentData(componentData);
}
}
// Adiciona cada novo interceptor.
foreach (Type type in registrationInfo.InterceptorCollection)
{
// Verifica se o interceptor já existe para o tipo registrado. Caso negativo, adiciona o interceptor.
if (registeredRegistrationInfo.InterceptorCollection.Any(p => p == type) == false)
{
AbstractComponentInfo componentInfo = (AbstractComponentInfo)registeredRegistrationInfo;
// Adiciona o interceptor.
componentInfo.AddInterceptor(type);
}
}
}
}
}
// Adiciona os componentes na lista de items registrados.
//RegistrationInfoCollection.AddRange(registrationInfoCollection);
}
private static object Resolve(Type interfaceType, string name, params object[] constructorParameters)
{
// Obtém a informação do registro de dependencias.
IRegistrationInfo registrationInfo = RegistrationInfoCollection.FirstOrDefault(p => p.InterfaceType == interfaceType);
// Verifica se existe uma mapeamento para a interface.
if (registrationInfo == null)
{
throw new InvalidOperationException(string.Format("The interface type {0} is not registered.", interfaceType.FullName));
}
// Obtém as informações do primeiro tipo concreto registrado, que será instanciado.
ComponentData componentData = null;
// Verifica se foi especificado o nome do tipo a ser retornado.
if (string.IsNullOrWhiteSpace(name) == true)
{
componentData = registrationInfo.ComponentDataCollection.OrderByDescending(p => p.IsDefault == true).FirstOrDefault();
}
else
{
componentData = registrationInfo.ComponentDataCollection.FirstOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
}
// Verifica se alguma classe concreta foi encontrada para a interface.
if (componentData == null)
{
throw new InvalidOperationException(string.Format("The interface type {0} does not have any associated concrete types.", interfaceType.FullName));
}
// Verifica se o tipo solicitado deve ser tratado como singleton.
if (componentData.IsSingleton == true)
{
// Verifica se o tipo existe no dicionário de objetos instanciados.
if (SingletonInstanceDictionary.ContainsKey(componentData.Name) == true)
{
// Retorna o objeto já existente.
return(SingletonInstanceDictionary[componentData.Name]);
}
}
// Obtém a instancia previamente definida pelo.
object returnInstance = componentData.Instance;
// Caso não exista uma instancia pré-definida, cria uma nova.
if (componentData.Instance == null)
{
// Cria uma nova instancia.
//returnInstance = CreateInstance(interfaceType, componentData, registrationInfo.InterceptorCollection, constructorParameters);
returnInstance = CreateInstance(interfaceType, componentData, registrationInfo, constructorParameters);
// Verifica se as propriedades desta classe que estejam registradas no container de injeção de dependência, devem ser instanciadas.
if (registrationInfo.ResolveDependencies == true)
{
// Obtém todas as propriedades que não sejam de sistema.
IEnumerable <PropertyInfo> propertyInfoCollection = interfaceType.GetProperties().Where(p => p.PropertyType.FullName.Equals("System") == false && p.CanWrite == true);
foreach (PropertyInfo propertyInfo in propertyInfoCollection)
{
Type propertyInterfaceType = (propertyInfo.PropertyType.IsInterface == true) ? propertyInfo.PropertyType : propertyInfo.PropertyType.GetInterface(string.Format("I{0}", propertyInfo.Name));
// Verifica se existe um registro para a interface da propriedade.
if (RegistrationInfoCollection.Any(p => p.InterfaceType == propertyInterfaceType) == false)
{
continue;
}
// Obtém uma instancia para o tipo da propriedade.
object propertyInstance = Resolve(propertyInterfaceType);
// Caso não tenha sido possível obter uma instancia, passa para a próxima propriedade.
if (propertyInstance == null)
{
continue;
}
// Define o valor da propriedade na instancia a ser retornada.
propertyInfo.SetValue(returnInstance, propertyInstance);
}
}
}
// Caso o tipo deva ser tratado como singleton, adiciona a instancia recém criada no dicionário de objetos instanciados.
if (componentData.IsSingleton == true && SingletonInstanceDictionary.ContainsKey(componentData.Name) == false)
{
SingletonInstanceDictionary.Add(componentData.Name, returnInstance);
}
return(returnInstance);
}
public RegistrationException(IRegistrationInfo info, Exception innerException = null)
: this(info.Type, info.Key, innerException)
{
}
public RegistrationException(IRegistrationInfo info, string additionalErrorDescription)
: this(info.Type, info.Key, additionalErrorDescription)
{
}
public InvocationInfo(object owner, IRegistrationInfo registrationInfo)
{
_ownerRef = new WeakReference(owner);
RegistrationInfo = registrationInfo;
}
// Optional
public virtual void Init(IRegistrationInfo key)
{
}
private static object CreateInstance(IRegistrationInfo registrationInfo, Type concreteType, params object[] args)
{
object returnInstance = Activator.CreateInstance(concreteType, args);
return(returnInstance);
}
//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.");
}
public PersonRecordWrapper ToPersonRecordWrapper(Dictionary <string, Type> typeMap, IRegistrationInfo registration)
{
var wrapper = ToWrapper(typeMap) as PersonRecordWrapper;
wrapper.Registration = registration;
return(wrapper);
}
internal TaskRegistrationInfo(IRegistrationInfo iRegInfo)
{
_v2RegInfo = iRegInfo;
}
internal abstract void RemoveInvocationInfo(IRegistrationInfo registrationInfo);
private static object CreateInstance <TInterface>(ComponentData componentData, IRegistrationInfo registrationInfo, params object[] constructorParameters)
{
return(CreateInstance(typeof(TInterface), componentData, registrationInfo, constructorParameters));
}