Ejemplo n.º 1
0
        /// <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);
        }
Ejemplo n.º 2
0
        public void RegistrationInfo_RegisterInterface_Test()
        {
            IRegistrationInfo registrationInfo = Component.For <IConfigurationUtilityMock>();

            Assert.IsNotNull(registrationInfo);
            Assert.IsNotNull(registrationInfo.InterfaceType);
            Assert.IsTrue(registrationInfo.ComponentDataCollection.Count() == 0);
        }
Ejemplo n.º 3
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;
        }
Ejemplo n.º 4
0
            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;
            }
Ejemplo n.º 5
0
        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;
        }
Ejemplo n.º 6
0
        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);
            }
Ejemplo n.º 8
0
        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);
        }
Ejemplo n.º 9
0
        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");
            //}
        }
Ejemplo n.º 10
0
        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);
        }
Ejemplo n.º 11
0
        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)));
        }
Ejemplo n.º 12
0
        /// <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);
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
 public RegistrationException(IRegistrationInfo info, Exception innerException = null)
     : this(info.Type, info.Key, innerException)
 {
 }
Ejemplo n.º 15
0
 public RegistrationException(IRegistrationInfo info, string additionalErrorDescription)
     : this(info.Type, info.Key, additionalErrorDescription)
 {
 }
Ejemplo n.º 16
0
 public InvocationInfo(object owner, IRegistrationInfo registrationInfo)
 {
     _ownerRef        = new WeakReference(owner);
     RegistrationInfo = registrationInfo;
 }
Ejemplo n.º 17
0
 // Optional
 public virtual void Init(IRegistrationInfo key)
 {
 }
Ejemplo n.º 18
0
        private static object CreateInstance(IRegistrationInfo registrationInfo, Type concreteType, params object[] args)
        {
            object returnInstance = Activator.CreateInstance(concreteType, args);

            return(returnInstance);
        }
Ejemplo n.º 19
0
        //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.");
        }
Ejemplo n.º 20
0
        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;
 }
Ejemplo n.º 22
0
 internal abstract void RemoveInvocationInfo(IRegistrationInfo registrationInfo);
Ejemplo n.º 23
0
 private static object CreateInstance <TInterface>(ComponentData componentData, IRegistrationInfo registrationInfo, params object[] constructorParameters)
 {
     return(CreateInstance(typeof(TInterface), componentData, registrationInfo, constructorParameters));
 }