/// <summary>
/// Constructor.
/// </summary>
/// <param name="container">Container.</param>
/// <param name="registeredType">Registered type.</param>
/// <param name="implementationType">Implementation type.</param>
public RegistrationBase(XerContainer container, Type registeredType, Type implementationType)
{
Container = container;
RegisteredType = registeredType;
RegisteredTypeInfo = registeredType.GetTypeInfo();
ImplementationType = implementationType;
ImplementationTypeInfo = implementationType.GetTypeInfo();
_constructor = LazyLoad(() =>
Container.Options.ConstructorSelector.SelectConstructor(ImplementationTypeInfo));
_injectableProperties = LazyLoad(() =>
Container.Options.InjectablePropertiesSelector.SelectProperties(ImplementationTypeInfo));
_constructorDependencies = LazyLoad(() =>
GetConstructorDependencies(Constructor));
_propertyDependencies = LazyLoad(() =>
GetPropertyDependencies(InjectableProperties));
// Create builder.
InstanceFactoryBuilder = CreateInstanceFactoryBuilder(this);
}
internal LifetimeScope(XerContainer container, string scopeName)
{
_container = container;
ScopeName = scopeName;
}
public SingletonRegistration(XerContainer container, Type contractType, object instance)
: base(container, contractType, instance.GetType())
{
// Add to container's singleton scope.
Container.SingletonScope.AddToScope(this, instance);
}
public SingletonRegistration(XerContainer container, Type contractType, Type implementationType)
: base(container, contractType, implementationType)
{
}
public LifetimeScopeManager(XerContainer container)
{
_contaner = container;
}
internal ControlledLifetimeScope(XerContainer container, string scopeName)
: base(container, scopeName)
{
}
//public override LifetimeScope LifetimeScope => new TransientLifetimeScope(Container);
public TransientRegistration(XerContainer container, Type interfaceType, Type implementationType)
: base(container, interfaceType, implementationType)
{
}
