Example #1
0
        /// <summary>
        /// Adds a registration.
        /// </summary>
        /// <param name="registration">The registration.</param>
        public void AddRegistration(RegistrationItem registration)
        {
            lock (_lock)
            {
                if (!HasRegistration(registration.ContractType))
                {
                    _registrations.Add(registration.ContractType, registration);
                }
                else
                {
                    // Duplicate registration for enumerable requests.
                    RegistrationItem duplicateItem;

                    _registrations.TryGetValue(registration.ContractType, out duplicateItem);

                    if (duplicateItem != null)
                    {
                        _duplicateRegistrations.Add(duplicateItem);
                        RemoveRegistration(duplicateItem.ContractType);
                    }

                    _duplicateRegistrations.Add(registration);
                }
            }
        }
        public void WithNullAsLifecycle_ArgumentExceptionThrown()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);

            Assert.That(() => fluentRegistration.ControlledBy(null), Throws.ArgumentException);
        }
        public void WithGenericTransientLifecycleArgument_LifecycleIsSetToTransient()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);

            fluentRegistration.ControlledBy<TransientLifecycle>();

            Assert.That(registrationItem.Lifecycle, Is.InstanceOf<TransientLifecycle>());
        }
        public void WithNull_GroupIsSetToNull()
        {
            var registrationItem = new RegistrationItem(null);
            var fluentRegistration = this.GetRegistration(registrationItem);

            fluentRegistration.WithGroup(null);

            Assert.That(registrationItem.Group, Is.EqualTo(null));
        }
        public void WithTwoArguments_AnonymousArgumentCountIsTwo()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);

            fluentRegistration.WithArguments(2, 3);

            Assert.That(registrationItem.Arguments.AnonymousArguments.Length, Is.EqualTo(2));
        }
        public void WithNull_ArgumentCountStaysOnZero()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);

            fluentRegistration.WithNamedArguments(null);

            Assert.That(registrationItem.Arguments.CountOfAllArguments, Is.EqualTo(0));
        }
        public void WithSingletonLifecycleTypeArgument_LifecycleIsSetToSingleton()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);

            fluentRegistration.ControlledBy(typeof(SingletonLifecycle));

            Assert.That(registrationItem.Lifecycle, Is.InstanceOf<SingletonLifecycle>());
        }
        public void WithString_GroupIsSetToStringValue()
        {
            var registrationItem = new RegistrationItem(null);
            var fluentRegistration = this.GetRegistration(registrationItem);
            var group = "test";

            fluentRegistration.WithGroup(group);

            Assert.That(registrationItem.Group, Is.EqualTo(group));
        }
        public void WithTwoNamedAnonymousTypeArguments_TheArgumentsAreCommited()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);

            fluentRegistration.WithNamedArguments(new { Foo = "foo", Bar = new Bar() });

            Assert.That(registrationItem.Arguments.NamedArguments.Count, Is.EqualTo(2));
            Assert.That(registrationItem.Arguments.NamedArguments["Foo"], Is.InstanceOf<string>());
            Assert.That(registrationItem.Arguments.NamedArguments["Bar"], Is.InstanceOf<Bar>());
        }
Example #10
0
        /// <summary>
        /// Gets whether two keys equals, or not.
        /// </summary>
        /// <param name="obj1">The first key.</param>
        /// <param name="obj2">The second key.</param>
        /// <returns><true /> if the keys equals each other, otherwise false.</returns>
        public static bool Equals(RegistrationItem obj1, RegistrationItem obj2)
        {
            if ((object.Equals(null, obj1) || object.Equals(null, obj2)) || (obj1.GetType() != obj2.GetType()))
            {
                return(false);
            }

            return(obj1.ContractType == obj2.ContractType &&
                   obj1.ImplementationType == obj2.ImplementationType &&
                   ReferenceEquals(obj1, obj2));
        }
        public void WithOneFooArgument_TheArgumentIsTheSame()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);
            var foo = new Foo();

            fluentRegistration.WithArguments(foo);

            Assert.That(registrationItem.Arguments.AnonymousArguments.Length, Is.EqualTo(1));
            Assert.That(registrationItem.Arguments.AnonymousArguments[0], Is.SameAs(foo));
        }
        public void WithOneNamedFooArgument_TheArgumentIsTheSame()
        {
            var registrationItem = new RegistrationItem();
            var fluentRegistration = this.GetRegistration(registrationItem);
            var key = "test";
            var foo = new Foo();

            fluentRegistration.WithNamedArguments(new Dictionary<string, object> { { key, foo } });

            Assert.That(registrationItem.Arguments.NamedArguments.Count, Is.EqualTo(1));
            Assert.That(registrationItem.Arguments.NamedArguments[key], Is.SameAs(foo));
        }
        /// <summary>
        /// Gets a fake registration container with given registered types.
        /// </summary>
        /// <param name="typesToRegister">The types to register.</param>
        /// <returns>The registration container with registered types.</returns>
        internal static RegistrationContainer GetRegistrationContainerFor(Type[] typesToRegister)
        {
            var registrationContainer = new RegistrationContainer();

            foreach (Type registeredType in typesToRegister)
            {
                var item = new RegistrationItem(registeredType);

                registrationContainer.Registrations.Add(new KeyValuePair<Type, RegistrationItem>(registeredType, item));
            }

            return registrationContainer;
        }
        /// <summary>
        /// Gets a fake registration container with given registered types.
        /// </summary>
        /// <param name="typesToRegister">The types to register.</param>
        /// <returns>The registration container with registered types.</returns>
        internal static RegistrationContainer GetRegistrationContainerFor(Type[] typesToRegister)
        {
            var registrationContainer = new RegistrationContainer();

            foreach (Type registeredType in typesToRegister)
            {
                var item = new RegistrationItem(registeredType);

                registrationContainer.AddRegistration(item);
            }

            return registrationContainer;
        }
        private ResolutionContext GetContext(Type contractType, Type implementationType)
        {
            var registrationContainer = new RegistrationContainer();

            var registration = new RegistrationItem(contractType)
                                   {
                                       Activator =
                                           new LightCore.Activation.Activators.ReflectionActivator
                                           (implementationType,
                                            new LightCore.Activation.Components.ConstructorSelector(),
                                            new LightCore.Activation.Components.ArgumentCollector()
                                           ),
                                       Lifecycle = new TransientLifecycle()
                                   };

            registrationContainer.AddRegistration(registration);

            return new ResolutionContext(new Container(registrationContainer), registrationContainer);
        }
 /// <summary>
 /// Try get a registration based upon a contract type.
 /// </summary>
 /// <param name="contractType">The contract type.</param>
 /// <param name="registrationItem">The registration item.</param>
 /// <returns>The registrationitem.</returns>
 public bool TryGetRegistration(Type contractType, out RegistrationItem registrationItem)
 {
     return this._registrations.TryGetValue(contractType, out registrationItem);
 }
Example #17
0
 internal IFluentRegistration GetRegistration(RegistrationItem registrationItem)
 {
     return new LightCore.Fluent.FluentRegistration(registrationItem);
 }
Example #18
0
        /// <summary>
        /// Gets whether two keys equals, or not.
        /// </summary>
        /// <param name="obj1">The first key.</param>
        /// <param name="obj2">The second key.</param>
        /// <returns><true /> if the keys equals each other, otherwise false.</returns>
        public static bool Equals(RegistrationItem obj1, RegistrationItem obj2)
        {
            if ((object.Equals(null, obj1) || object.Equals(null, obj2)) || (obj1.GetType() != obj2.GetType()))
            {
                return false;
            }

            return obj1.ContractType == obj2.ContractType
                   && obj1.ImplementationType == obj2.ImplementationType
                   && ReferenceEquals(obj1, obj2);
        }
Example #19
0
 /// <summary>
 /// Try get a registration based upon a contract type.
 /// </summary>
 /// <param name="contractType">The contract type.</param>
 /// <param name="registrationItem">The registration item.</param>
 /// <returns>The registrationitem.</returns>
 public bool TryGetRegistration(Type contractType, out RegistrationItem registrationItem)
 {
     return(_registrations.TryGetValue(contractType, out registrationItem));
 }
        /// <summary>
        /// Adds a registration.
        /// </summary>
        /// <param name="registration">The registration.</param>
        public void AddRegistration(RegistrationItem registration)
        {
            lock (this._lock)
            {
                if (!this.HasRegistration(registration.ContractType))
                {
                    this._registrations.Add(registration.ContractType, registration);
                }
                else
                {
                    // Duplicate registration for enumerable requests.
                    RegistrationItem duplicateItem;

                    this._registrations.TryGetValue(registration.ContractType, out duplicateItem);

                    if (duplicateItem != null)
                    {
                        this._duplicateRegistrations.Add(duplicateItem);
                        this.RemoveRegistration(duplicateItem.ContractType);
                    }

                    this._duplicateRegistrations.Add(registration);
                }
            }
        }