public void WhenEnumTypeIsProvidedForIntParameterConversionWillBeAttempted()
{
var ci = typeof(CtorWithInt).GetTypeInfo().DeclaredConstructors.Single();
var cpb = new ConstructorBinder(ci).Bind(new[] { new PositionalParameter(0, Foo.B), }, new ContainerBuilder().Build());
var instance = (CtorWithInt)cpb.Instantiate();
Assert.Equal(1, instance.Value);
}
public void Should_use_constructor()
{
var binder = new ConstructorBinder <MyClass>(provider);
var result = binder.Bind(settings);
result.Errors.Should().BeEmpty();
result.Value.GetValue().Should().BeTrue();
}
public void WhenAnExceptionIsThrownFromAConstructor_TheInnerExceptionIsWrapped()
{
var ci = typeof(ThrowsInCtor).GetTypeInfo().DeclaredConstructors.Single();
var cpb = new ConstructorBinder(ci).Bind(Enumerable.Empty <Parameter>(), new ContainerBuilder().Build());
var dx = Assert.Throws <DependencyResolutionException>(() =>
cpb.Instantiate());
Assert.Contains(typeof(ThrowsInCtor).Name, dx.Message);
Assert.Equal(ThrowsInCtor.Message, dx.InnerException.Message);
}
public void Execute(ResolveRequestContext context, Action <ResolveRequestContext> next)
{
next(context);
if (context.Instance == null || context.Instance.IsProxy())
{
return;
}
if (!(context.Registration.Activator is ReflectionActivator ||
context.Registration.Activator is DelegateActivator ||
context.Registration.Activator is InstanceActivator))
{
return;
}
var limitType = context.Instance.GetType();
if (!limitType.GetTypeInfo().CanInherited())
{
return;
}
if (excepts.Any(x => limitType.Name.Matches(x)) || excepts.Any(x => limitType.Namespace.Matches(x)))
{
return;
}
var services = context.Registration.Services.Select(x => ((IServiceWithType)x).ServiceType).ToList();
if (!services.All(x => x.GetTypeInfo().CanInherited()) || services.All(x => x.GetTypeInfo().IsNonAspect()))
{
return;
}
var aspectValidator = new AspectValidatorBuilder(context.Resolve <IAspectConfiguration>()).Build();
if (services.All(x => !aspectValidator.Validate(x, true)) && !aspectValidator.Validate(limitType, false))
{
return;
}
var proxyTypeGenerator = context.Resolve <IProxyTypeGenerator>();
Type proxyType; object instance;
var interfaceType = services.FirstOrDefault(x => x.GetTypeInfo().IsInterface);
if (interfaceType == null)
{
var baseType = services.FirstOrDefault(x => x.GetTypeInfo().IsClass) ?? limitType;
proxyType = proxyTypeGenerator.CreateClassProxyType(baseType, limitType);
//Autofac.Core.Activators.Reflection.ReflectionActivator
var constructorSelector = new MostParametersConstructorSelector();
var constructorFinder = new DefaultConstructorFinder(type => type.GetTypeInfo().DeclaredConstructors.ToArray());
var availableConstructors = constructorFinder.FindConstructors(proxyType);
if (availableConstructors.Length == 0)
{
throw new NoConstructorsFoundException(proxyType, $"No constructors on type '{proxyType}' can be found with the constructor finder '{constructorFinder}'.");
}
var binders = new ConstructorBinder[availableConstructors.Length];
for (var idx = 0; idx < availableConstructors.Length; idx++)
{
binders[idx] = new ConstructorBinder(availableConstructors[idx]);
}
var allBindings = GetAllBindings(binders, context, context.Parameters);
var selectedBinding = constructorSelector.SelectConstructorBinding(allBindings, context.Parameters);
instance = selectedBinding.Instantiate();
}
else
{
proxyType = proxyTypeGenerator.CreateInterfaceProxyType(interfaceType, limitType);
instance = Activator.CreateInstance(proxyType, new object[] { context.Resolve <IAspectActivatorFactory>(), context.Instance });
}
var propertyInjector = context.Resolve <IPropertyInjectorFactory>().Create(instance.GetType());
propertyInjector.Invoke(instance);
context.Instance = instance;
}
