public CompositeDependencyResolver(ICompactContainer container)
{
resolvers.Add(new ParameterDependencyResolver());
resolvers.Add(new ConfigurationResolver(container));
resolvers.Add(new SimpleDependencyResolver(container));
resolvers.Add(new ArrayDependencyResolver(container));
}
public CompositeDependencyResolver(ICompactContainer container)
{
resolvers.Add(new ParameterDependencyResolver());
resolvers.Add(new ConfigurationResolver(container));
resolvers.Add(new SimpleDependencyResolver(container));
resolvers.Add(new ArrayDependencyResolver(container));
}
public bool TryRegisterUnknownType(Type type, ICompactContainer container)
{
if (!(type.IsInterface || type.IsAbstract))
{
container.AddComponentInfo(new ComponentInfo(type.FullName, type, type, container.DefaultLifestyle));
return true;
}
return false;
}
public bool TryRegisterUnknownType(Type type, ICompactContainer container)
{
if (!(type.IsInterface || type.IsAbstract))
{
container.AddComponentInfo(new ComponentInfo(type.FullName, type, type, container.DefaultLifestyle));
return(true);
}
return(false);
}
public void Apply(ICompactContainer container)
{
// by default we scan all concrete types of the pointed assembly (even non-public ones)
// and we register each type as many times as needed acording to the specified configuration
// (a given type can be registered more than once with different services)
foreach (var type in assembly.GetTypes().Where(t => t.IsAbstract == false && t.IsClass))
{
foreach (var part in parts)
{
part.ApplyTo(type, container);
}
}
}
void IAllTypesRegistrationPart.ApplyTo(Type type, ICompactContainer container)
{
if (!typeFilter(type))
{
return;
}
var serviceType = ServiceSelector(type);
var registration = Component.For(serviceType);
registration.ImplementedBy(type);
if (configurationDelegate != null)
{
configurationDelegate(registration);
}
registration.Apply(container);
}
public void GetPropertyData()
{
TestObject test1 = new TestObject();
test1.Desc = "xxx";
ICompactContainer container = mocks.CreateMock <ICompactContainer>();
Expect.Call(container.Resolve(typeof(ITestObject))).Return(test1);
mocks.ReplayAll();
PropertyDataResolver resolver = new PropertyDataResolver(container);
PropertyData data = resolver.Get("InversionOfControl.Tests.PropertyDataResolverTests+ITestObject, CompactContainer.Tests, Desc");
mocks.VerifyAll();
Assert.AreEqual(test1, data.Owner);
Assert.AreEqual("Desc", data.Name);
Assert.AreEqual("xxx", data.Value);
Assert.AreEqual(typeof(ITestObject).GetProperty("Desc"), data.Info);
}
public DefaultConstructorResolver(ICompactContainer container)
{
this.container = container;
}
public ArrayDependencyResolver(ICompactContainer container)
{
this.container = container;
}
public AttributedConstructorResolver(ICompactContainer container, Type attributeType)
: base(container)
{
this.attributeType = attributeType;
}
public void Init(ICompactContainer container)
{
Initialized = true;
}
void IRegistration.Apply(ICompactContainer container)
{
allTypesPart.Apply(container);
}
public DefaultActivator(ICompactContainer container, IConstructorResolver constructorResolver)
{
this.container = container;
this.constructorResolver = constructorResolver;
}
public AttributedActivator(ICompactContainer container)
: this(container, typeof(InjectAttribute))
{
}
public SimpleDependencyResolver(ICompactContainer container)
{
this.container = container;
}
public SimpleDependencyResolver(ICompactContainer container)
{
this.container = container;
}
public DefaultConstructorResolver(ICompactContainer container)
{
this.container = container;
}
public AttributedActivator(ICompactContainer container, Type attributeType)
: base(container, new AttributedConstructorResolver(container, attributeType))
{
}
public AttributedActivator(ICompactContainer container)
: this(container, typeof(InjectAttribute))
{
}
public StartableActivator(ICompactContainer container)
{
this.container = container;
}
public AttributedConstructorResolver(ICompactContainer container, Type attributeType)
: base(container)
{
this.attributeType = attributeType;
}
public ConfigurationResolver(ICompactContainer container)
{
this.container = container;
}
public void Init(ICompactContainer container)
{
Initialized = true;
}
public StartableActivator(ICompactContainer container)
{
this.container = container;
}
public DefaultActivator(ICompactContainer container)
: this(container, new DefaultConstructorResolver(container))
{
}
public AttributedActivator(ICompactContainer container, Type attributeType)
: base(container, new AttributedConstructorResolver(container, attributeType))
{
}
public ConfigurationResolver(ICompactContainer container)
{
this.container = container;
}
public void Apply(ICompactContainer container)
{
if (ImplementationType == null)
{
if (instance != null)
{
ImplementationType = instance.GetType();
}
else
{
if (ServiceTypes.Count() != 1)
{
throw new CompactContainerException("Cannot infer implementation type when more than one service is specified: " +
ServiceTypes.Select(t => t.Name).ToCommaSeparatedString());
}
ImplementationType = ServiceTypes.Single();
}
}
if (ImplementationType.IsAbstract)
{
throw new CompactContainerException("Cannot register implementation type " + ImplementationType.FullName +
" because it is abstract");
}
// name calculation
if (name == null)
{
if (ImplementationType != null)
{
name = ImplementationType.FullName;
}
else if (instance != null)
{
name = instance.GetType().FullName;
}
else if (ServiceTypes.Count() > 0)
{
name = ServiceTypes.First().FullName;
}
else
{
throw new CompactContainerException("Cannot infer name for component");
}
}
var ci = new ComponentInfo(name, ServiceTypes, ImplementationType, lifestyle ?? container.DefaultLifestyle)
{
Instance = instance,
};
if (registrationParts != null)
{
foreach (var part in registrationParts)
{
part.ApplyTo(ci);
}
}
container.AddComponentInfo(ci);
}
public ArrayDependencyResolver(ICompactContainer container)
{
this.container = container;
}
