public void ExpressionRegistrationSetLifetimeThrowsExceptionIfInvalidLifetimeIsSupplied() { var lifetime = new TransientLifetime(); var reg = new ExpressionRegistration<IFoo>(x => new Foo1(), lifetime, CompileMode.Delegate); reg.SetLifetime((ILifetime)null); }
public void ExpressionRegistrationCanBeChanged() { var container = new IocContainer(); var lifetime = new TransientLifetime(); var reg = new ExpressionRegistration<IFoo>(container, x => new Foo1(), lifetime, CompileMode.Delegate); Assert.AreSame(reg.Lifetime, lifetime); Assert.AreEqual(reg.CompileMode, CompileMode.Delegate); var get1 = reg.GetInstance(); var newLifetime = new ContainerLifetime(); var newCompileMode = CompileMode.Dynamic; // Set new lifetime reg.SetLifetime(newLifetime); Assert.AreSame(reg.Lifetime, newLifetime); // Set different compile mode reg.SetCompileMode(newCompileMode); Assert.AreEqual(reg.CompileMode, newCompileMode); var get2 = reg.GetInstance(); var get3 = reg.GetInstance(); // Check that the lifetime is also being used Assert.AreNotSame(get1, get2); Assert.AreSame(get2, get3); }
public void ExpressionRegistrationSetCompileModeThrowsExceptionIfInvalidCompileModeIsSupplied() { var container = new IocContainer(); var lifetime = new TransientLifetime(); var reg = new ExpressionRegistration<IFoo>(container, x => new Foo1(), lifetime, CompileMode.Delegate); reg.SetCompileMode((CompileMode)124); }
private InstanceProducer BuildMutableCollectionProducerFromControlledCollection( Type serviceType, Type elementType, MutableCollectionType collectionType) { Expression expression = this.BuildMutableCollectionExpressionFromControlledCollection(serviceType, elementType); // Technically, we could determine the longest lifestyle out of the elements of the collection, // instead of using Transient here. This would make it less likely for the user to get false // positive Lifestyle Mismatch warnings. Problem with that is that trying to retrieve the // longest lifestyle might cause the array to be cached in a way that is incorrect, because // who knows what kind of lifestyles the used created. Registration registration = new ExpressionRegistration(expression, serviceType, Lifestyle.Transient, this); return(new InstanceProducer(serviceType, registration) { IsContainerAutoRegistered = !this.GetAllInstances(elementType).Any() }); }
private InstanceProducer BuildMutableCollectionProducerFromUncontrolledCollection( Type serviceType, Type elementType) { var enumerableProducer = this.GetRegistration(typeof(IEnumerable <>).MakeGenericType(elementType)); Expression enumerableExpression = enumerableProducer.BuildExpression(); var expression = Expression.Call( method: serviceType.IsArray ? EnumerableToArrayMethod.MakeGenericMethod(elementType) : EnumerableToListMethod.MakeGenericMethod(elementType), arg0: enumerableExpression); Registration registration = new ExpressionRegistration(expression, serviceType, Lifestyle.Transient, this); return(new InstanceProducer(serviceType, registration) { IsContainerAutoRegistered = true }); }
internal void AddAppliedDecorator( Type serviceType, Type decoratorType, Container container, Lifestyle lifestyle, Expression decoratedExpression, IEnumerable <KnownRelationship> decoratorRelationships = null) { var registration = new ExpressionRegistration( decoratedExpression, decoratorType, lifestyle, container); registration.ReplaceRelationships(decoratorRelationships ?? Enumerable.Empty <KnownRelationship>()); var producer = new InstanceProducer(serviceType, registration) { IsDecorated = true }; this.appliedDecorators.Add(new DecoratorInfo(decoratorType, producer)); }
public void ExpressionRegistrationWorksLikeExpected() { Expression<Func<IResolver, IFoo>> expression = x => new Foo1(); var container = new IocContainer(); var lifetime = new TransientLifetime(); var compileMode = CompileMode.Dynamic; var reg = new ExpressionRegistration<IFoo>(container, expression, lifetime, compileMode); Assert.AreEqual(reg.ReturnType, typeof(IFoo)); Assert.AreEqual(reg.CompileMode, compileMode); //Assert.AreSame(reg.Expression, expression); // Is being converted to Expression<Func<IResolver, object>> Assert.AreSame(reg.Lifetime, lifetime); // Test GetInstance var instance = reg.GetInstance(); Assert.IsInstanceOfType(instance, typeof(Foo1)); }
protected InstanceProducer CreateDecorateeFactoryProducer( ParameterInfo parameter, InstanceProducer decorateeProducer) { // We create a dummy expression with a null value. Much easier than passing on the real delegate. // We won't miss it, since the created InstanceProducer is just a dummy for purposes of analysis. var dummyExpression = Expression.Constant(null, parameter.ParameterType); var registration = new ExpressionRegistration(dummyExpression, this.Container); var relationship = new KnownRelationship( parameter.ParameterType, Lifestyle.Singleton, decorateeProducer) { // Make sure the relationship is not traversed when doing verification, because that leads to // false positivies. UseForVerification = false }; registration.AddRelationship(relationship); return(new InstanceProducer(parameter.ParameterType, registration)); }
public void ExpressionRegistrationWorksLikeExpected() { Expression <Func <IResolver, IFoo> > expression = x => new Foo1(); var container = new IocContainer(); var lifetime = new TransientLifetime(); var compileMode = CompileMode.Dynamic; var reg = new ExpressionRegistration <IFoo>(container, expression, lifetime, compileMode); Assert.AreEqual(reg.ReturnType, typeof(IFoo)); Assert.AreEqual(reg.CompileMode, compileMode); //Assert.AreSame(reg.Expression, expression); // Is being converted to Expression<Func<IResolver, object>> Assert.AreSame(reg.Lifetime, lifetime); // Test GetInstance var instance = reg.GetInstance(); Assert.IsInstanceOfType(instance, typeof(Foo1)); }
protected ServiceTypeDecoratorInfo GetServiceTypeInfo(Expression originalExpression, InstanceProducer registeredProducer, Type registeredServiceType, Lifestyle lifestyle) { // registeredProducer.ServiceType and registeredServiceType are different when called by // container uncontrolled decorator. producer.ServiceType will be IEnumerable<T> and // registeredServiceType will be T. Func <Type, InstanceProducer> producerBuilder = implementationType => { // The InstanceProducer created here is used to do correct diagnostics. We can't return the // registeredProducer here, since the lifestyle of the original producer can change after // the ExpressionBuilt event has ran, which means that this would invalidate the diagnostic // results. var registration = new ExpressionRegistration(originalExpression, implementationType, lifestyle, this.Container); registration.ReplaceRelationships(registeredProducer.GetRelationships()); return(new InstanceProducer(registeredServiceType, registration)); }; return(this.GetServiceTypeInfo(originalExpression, registeredProducer, producerBuilder)); }
internal bool SatisfiesPredicate() { // We don't have an expression at this point, since the instances are not created by the container. // Therefore we fake an expression so it can still be passed on to the predicate the user might // have defined. var expression = Expression.Constant(null, this.registeredServiceType); var registration = new ExpressionRegistration( expression, this.registeredServiceType, Lifestyle.Unknown, this.Container); registration.ReplaceRelationships(this.e.InstanceProducer.GetRelationships()); var info = this.GetServiceTypeInfo( this.e, originalExpression: expression, originalRegistration: registration, registeredServiceType: this.registeredServiceType); this.Context = this.CreatePredicateContext(this.registeredServiceType, expression, info); return(this.SatisfiesPredicate(this.Context)); }
internal void ApplyDecorator() { var registration = new ExpressionRegistration(this.e.Expression, this.registeredServiceType, Lifestyle.Unknown, this.Container); registration.ReplaceRelationships(this.e.InstanceProducer.GetRelationships()); var serviceTypeInfo = this.GetServiceTypeInfo(this.e.Expression, this.e.InstanceProducer, registration, this.registeredServiceType); Registration decoratorRegistration; var decoratedExpression = this.BuildDecoratorExpression(out decoratorRegistration); this.e.Expression = decoratedExpression; // Add the decorator to the list of applied decorator. This way users can use this // information in the predicate of the next decorator they add. serviceTypeInfo.AddAppliedDecorator(this.registeredServiceType, this.decoratorType, this.Container, this.Lifestyle, decoratedExpression); this.e.KnownRelationships.AddRange(decoratorRegistration.GetRelationships()); }
public void CachedLifetimeExtensionMethodThrowsExceptionIfPolicyParameterIsNull() { var container = new IocContainer(); var reg = new ExpressionRegistration<IFoo>(container, resolver => new Foo1(), new TransientLifetime()); LifetimeRegistrationExtensions.WithCachedLifetime(reg, null); }
private Expression HandleMethodCall(Type type, object key = null) { // Split up this method ? IRegistration registration; if (!TryGetRegistration(type, key, out registration)) { // Not able to find registration referenced. // Could choose to ignore it and let it fail later when trying to Resolve if the type/key havent been added to the index inbetween then. var exceptionDescription = "Cannot Compile Registration. The registration have a reference to Type: " + type.Name; if (key != null) exceptionDescription += " with Key: " + key; exceptionDescription += " which isn't registered."; // TODO: Throw CompileException or something ? throw new RegistrationException(_currentRegistration, exceptionDescription); } // Only possible to compile ExpressionRegistration's var expressionRegistration = registration as ExpressionRegistration; if (expressionRegistration != null) { // Currently the Compiler only support compiling TransientLifetime's if (expressionRegistration.Lifetime.GetType() == typeof(TransientLifetime)) // Check specific type incase something changes in the future and TransientLifetime is no longer sealed? in stead of using "is TransientLifetime" { // Keep visiting and try to inline the expression // Recursive call until deepest nested ExpressionRegistration with TransientLifetime is found // Change current registration to new registration which should be visited and save current for later var current = _currentRegistration; _currentRegistration = expressionRegistration; // Visit var expression = this.Visit(expressionRegistration.Expression.Body); // Change it back again _currentRegistration = current; return expression; } } return null; }
private static InitializationContext CreateDummyInitializationContext() { var registration = new ExpressionRegistration(Expression.Constant(null), new Container()); return(new InitializationContext(new InstanceProducer(typeof(object), registration), registration)); }
public void ExpressionRegistrationThrowsExceptionIfLifetimeIsNull() { var reg = new ExpressionRegistration<object>(x => new object(), null); }
public void ExpressionRegistrationThrowsExceptionIfResolverIsNull() { var reg = new ExpressionRegistration <object>(null, x => new object(), new TransientLifetime()); }
public void ExpressionRegistrationThrowsExceptionIfLifetimeIsNull() { var container = new IocContainer(); var reg = new ExpressionRegistration<object>(container, x => new object(), null); }
public void ExpressionRegistrationThrowsExceptionIfExpressionIsNull() { var container = new IocContainer(); var reg = new ExpressionRegistration <object>(container, null, new TransientLifetime()); }
private static InitializerContext CreateDummyInitializationContext() { var registration = new ExpressionRegistration(Expression.Constant(null), new Container()); return(new InitializerContext(registration)); }
public void ExpressionRegistrationThrowsExceptionIfResolverIsNull() { var reg = new ExpressionRegistration<object>(null, x => new object(), new TransientLifetime()); }
public void ExpressionRegistrationThrowsExceptionIfExpressionIsNull() { var container = new IocContainer(); var reg = new ExpressionRegistration<object>(container, null, new TransientLifetime()); }
public void ExpressionRegistrationThrowsExceptionIfLifetimeIsNull() { var container = new IocContainer(); var reg = new ExpressionRegistration <object>(container, x => new object(), null); }
public void ExpressionRegistrationThrowsExceptionIfExpressionIsNull() { var reg = new ExpressionRegistration<object>(null, new TransientLifetime()); }