protected virtual Expression CompileRegistrationIntoExpression(IRegistration registration)
        {
            if (registration == null)
            {
                throw new ArgumentNullException("registration");
            }

            // Check if it is an InstanceRegistration<>
            if (ReflectionHelper.IsInstanceOfGenericType(typeof(InstanceRegistration <>), registration) && _targetRegistration.CompileMode == CompileMode.Delegate)
            {
                var instance = registration.GetInstance();
                return(ConstantExpression.Constant(instance));
            }

            // Check if it is an IExpressionRegistration
            var expReg = registration as IExpressionRegistration;

            if (expReg != null)
            {
                // Check if the lifetime can be compiled

                if (expReg.Lifetime is TransientLifetime)
                {
                    // Keep visiting and try to inline the expression of the Registration found
                    // Recursive call until deepest nested ExpressionRegistration with TransientLifetime is found

                    // About to visit a child to the current - current becomes parent and registration/child to visit becomes current
                    var parent = _currentVisitedRegistration;
                    _currentVisitedRegistration = expReg;

                    // Visit - visit the body and return it so it is inlined within the original Expression<Func<IResolver, object>>
                    var expression = Visit(expReg.Expression.Body);

                    // Returned from visiting child - change it back again
                    _currentVisitedRegistration = parent;

                    return(expression);
                }

                if (expReg.Lifetime is ContainerLifetime && _targetRegistration.CompileMode == CompileMode.Delegate)
                {
                    var instance = expReg.GetInstance();
                    return(ConstantExpression.Constant(instance));
                }
            }

            // Returning null will make it keep visiting
            return(null);
        }
		public Expression<Func<IResolver, object>> Compile(IExpressionRegistration registration)
		{
			if (registration == null)
				throw new ArgumentNullException("registration");

			_targetRegistration = _currentVisitedRegistration = registration;
			_targetParameter = registration.Expression.Parameters[0];
			
			_visitCount = 0;

			// Start visiting expression to get compiled expression
			var compiledExpression = (Expression<Func<IResolver, object>>)Visit(registration.Expression);

			return compiledExpression;
		}
		private void TestRegister(IocContainer container, IExpressionRegistration registration, object key = null)
		{
			Assert.IsInstanceOfType(registration, typeof(ExpressionRegistration<IFooBar>));

			// Check registration
			Assert.IsTrue(registration.ReturnType == typeof(IFooBar));
			Assert.IsTrue(registration.CompileMode == CompileMode.Delegate);

			// Check resolved type
			var instance = (IFooBar)registration.GetInstance();
			Assert.IsInstanceOfType(instance, typeof(FooBar));
			Assert.IsInstanceOfType(instance.Foo, typeof(Foo1));
			Assert.IsInstanceOfType(instance.Bar, typeof(Bar1));

			// Check index
			Assert.IsTrue(key == null ? container.Index.Contains(registration.ReturnType) : container.Index.Contains(registration.ReturnType, key));
		}
		protected virtual Expression CompileRegistrationIntoExpression(IRegistration registration)
		{
			if (registration == null)
				throw new ArgumentNullException("registration");
			
			// Check if it is an InstanceRegistration<>
			if (ReflectionHelper.IsInstanceOfGenericType(typeof(InstanceRegistration<>), registration) && _targetRegistration.CompileMode == CompileMode.Delegate)
			{
				var instance = registration.GetInstance();
				return ConstantExpression.Constant(instance);
			}

			// Check if it is an IExpressionRegistration
			var expReg = registration as IExpressionRegistration;
			if (expReg != null)
			{
				// Check if the lifetime can be compiled

				if (expReg.Lifetime is TransientLifetime)
				{
					// Keep visiting and try to inline the expression of the Registration found
					// Recursive call until deepest nested ExpressionRegistration with TransientLifetime is found

					// About to visit a child to the current - current becomes parent and registration/child to visit becomes current
					var parent = _currentVisitedRegistration;
					_currentVisitedRegistration = expReg;

					// Visit - visit the body and return it so it is inlined within the original Expression<Func<IResolver, object>>
					var expression = Visit(expReg.Expression.Body);

					// Returned from visiting child - change it back again
					_currentVisitedRegistration = parent;

					return expression;
				}

				if (expReg.Lifetime is ContainerLifetime && _targetRegistration.CompileMode == CompileMode.Delegate)
				{
					var instance = expReg.GetInstance();
					return ConstantExpression.Constant(instance);
				}
			}

			// Returning null will make it keep visiting
			return null;
		}
        public Expression <Func <IResolver, object> > Compile(IExpressionRegistration registration)
        {
            if (registration == null)
            {
                throw new ArgumentNullException("registration");
            }

            _targetRegistration = _currentVisitedRegistration = registration;
            _targetParameter    = registration.Expression.Parameters[0];

            _visitCount = 0;

            // Start visiting expression to get compiled expression
            var compiledExpression = (Expression <Func <IResolver, object> >)Visit(registration.Expression);

            return(compiledExpression);
        }
Exemple #6
0
        private void TestRegister(IocContainer container, IExpressionRegistration registration, object key = null)
        {
            Assert.IsInstanceOfType(registration, typeof(ExpressionRegistration <IFooBar>));

            // Check registration
            Assert.IsTrue(registration.ReturnType == typeof(IFooBar));
            Assert.IsTrue(registration.CompileMode == CompileMode.Delegate);

            // Check resolved type
            var instance = (IFooBar)registration.GetInstance();

            Assert.IsInstanceOfType(instance, typeof(FooBar));
            Assert.IsInstanceOfType(instance.Foo, typeof(Foo1));
            Assert.IsInstanceOfType(instance.Bar, typeof(Bar1));

            // Check index
            Assert.IsTrue(key == null ? container.Index.Contains(registration.ReturnType) : container.Index.Contains(registration.ReturnType, key));
        }