public IInstanceFactory Handle(IResolverRequest request, Func<IResolverRequest, IInstanceFactory> nextHandler) { if (request == null) throw new ArgumentNullException("request"); if (nextHandler == null) throw new ArgumentNullException("nextHandler"); // If the component handler is last in the pipeline, this will return null. // However, it might not *always* be the last handler, so stick to the pattern // and pass to the next handler rather than returning null explicitly. if (request.RequestType.IsAbstract) return nextHandler(request); var ctors = request.RequestType .GetConstructors(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance); // this bad boy does the actual resolving... var ctorResolver = new ConstructorResolver(_pipeline); // ... we just order the results var factory = ctors .Select(ctor => ctorResolver.TryResolve(request, ctor)) .Where(f => f != null) // remove unresolvable ctors .OrderByDescending(f => f.Resolvable) // order by most parameters .OrderBy(f => f.Optional) // with the least optional parameters .FirstOrDefault(); return factory; }
public TDelegate ExecuteConstructorLambda <TDelegate>(ConstructorInfo ctor) where TDelegate : class { var resolver = new ConstructorResolver(ctor); return(Lambda.ResolveConstructorTo <TDelegate>(resolver) .ToLambda() .Compile()); }
public void ShouldSelectConstructorWithMostResolvableParameters() { var targetType = typeof(Vehicle); var constructorImplementations = (from c in typeof(Vehicle).GetConstructors() select new ConstructorCall(c) as IImplementation <ConstructorInfo>).AsEnumerable(); IImplementation <ConstructorInfo> expectedImplementation = GetExpectedConstructorImplementation(constructorImplementations); var map = new Mock <IDependencyContainer>(); map.Expect(m => m.Contains(It.IsAny <Dependency>())).Returns(true); map.Expect(m => m.Dependencies).Returns(new IDependency[] {}); var constructorResolver = new ConstructorResolver(); IImplementation <ConstructorInfo> result = constructorResolver.ResolveFrom(targetType, map.Object); Assert.AreEqual(expectedImplementation.Target, result.Target); map.VerifyAll(); }
public void CanApplyConstructorArgsToAbstractType() { IResource resource = new ReadOnlyXmlTestResource("ctor-args.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject rod = (TestObject)xof.GetObject("rod"); Assert.AreEqual(1, rod.Age); RootObjectDefinition def = (RootObjectDefinition)xof.GetObjectDefinition("rod"); ConstructorResolver resolver = new ConstructorResolver(xof, xof, new SimpleInstantiationStrategy(), new ObjectDefinitionValueResolver(xof)); ConstructorInstantiationInfo ci = resolver.GetConstructorInstantiationInfo("rod", def, null, null); AbstractObjectDefinition objDef = (AbstractObjectDefinition)xof.GetObjectDefinition("foo"); objDef.IsAbstract = false; TestObject foo = (TestObject)xof.GetObject("foo"); Assert.AreEqual(2, foo.Age); }
/// <summary> /// Applies attributes to the proxy class. /// </summary> /// <param name="typeBuilder">The type builder to use.</param> /// <param name="targetType">The proxied class.</param> /// <see cref="IProxyTypeBuilder.ProxyTargetAttributes"/> /// <see cref="IProxyTypeBuilder.TypeAttributes"/> protected override void ApplyTypeAttributes(TypeBuilder typeBuilder, Type targetType) { foreach (object attr in GetTypeAttributes(targetType)) { if (attr is CustomAttributeBuilder) { typeBuilder.SetCustomAttribute((CustomAttributeBuilder)attr); } else if (attr is CustomAttributeData) { typeBuilder.SetCustomAttribute( ReflectionUtils.CreateCustomAttribute((CustomAttributeData)attr)); } else if (attr is Attribute) { typeBuilder.SetCustomAttribute( ReflectionUtils.CreateCustomAttribute((Attribute)attr)); } else if (attr is IObjectDefinition) { RootObjectDefinition objectDefinition = (RootObjectDefinition)attr; //TODO check that object definition is for an Attribute type. //Change object definition so it can be instantiated and make prototype scope. objectDefinition.IsAbstract = false; objectDefinition.IsSingleton = false; string objectName = ObjectDefinitionReaderUtils.GenerateObjectName(objectDefinition, objectFactory); objectFactory.RegisterObjectDefinition(objectName, objectDefinition); //find constructor and constructor arg values to create this attribute. ConstructorResolver constructorResolver = new ConstructorResolver(objectFactory, objectFactory, new SimpleInstantiationStrategy(), new ObjectDefinitionValueResolver(objectFactory)); ConstructorInstantiationInfo ci = constructorResolver.GetConstructorInstantiationInfo(objectName, objectDefinition, null, null); if (objectDefinition.PropertyValues.PropertyValues.Count == 0) { CustomAttributeBuilder cab = new CustomAttributeBuilder(ci.ConstructorInfo, ci.ArgInstances); typeBuilder.SetCustomAttribute(cab); } else { object attributeInstance = objectFactory.GetObject(objectName); IObjectWrapper wrappedAttributeInstance = new ObjectWrapper(attributeInstance); PropertyInfo[] namedProperties = wrappedAttributeInstance.GetPropertyInfos(); object[] propertyValues = new object[namedProperties.Length]; for (int i = 0; i < namedProperties.Length; i++) { propertyValues[i] = wrappedAttributeInstance.GetPropertyValue(namedProperties[i].Name); } CustomAttributeBuilder cab = new CustomAttributeBuilder(ci.ConstructorInfo, ci.ArgInstances, namedProperties, propertyValues); typeBuilder.SetCustomAttribute(cab); } } } }