private static ContainerControlledItem[] GetClosedGenericImplementationsFor(
Type closedGenericServiceType, IEnumerable <ContainerControlledItem> containerControlledItems)
{
return((
from item in containerControlledItems
let openGenericImplementation = item.ImplementationType
let builder = new GenericTypeBuilder(closedGenericServiceType, openGenericImplementation)
let result = builder.BuildClosedGenericImplementation()
where result.ClosedServiceTypeSatisfiesAllTypeConstraints
select item.Registration != null
? item
: ContainerControlledItem.CreateFromType(
openGenericImplementation, result.ClosedGenericImplementation !))
.ToArray());
}
internal override void AddControlledRegistrations(Type serviceType,
ContainerControlledItem[] registrations, bool append)
{
if (append)
{
throw new NotSupportedException(
StringResources.AppendingRegistrationsToContainerUncontrolledCollectionsIsNotSupported(
serviceType));
}
else
{
throw new NotSupportedException(
StringResources.MixingRegistrationsWithControlledAndUncontrolledIsNotSupported(serviceType,
controlled: true));
}
}
private InstanceProducer CreateNewExternalProducer(ContainerControlledItem item)
{
if (!Types.IsConcreteConstructableType(item.ImplementationType))
{
throw new ActivationException(
StringResources.UnregisteredAbstractionFoundInCollection(
serviceType: typeof(TService),
registeredType: item.RegisteredImplementationType,
foundAbstractType: item.ImplementationType));
}
Lifestyle lifestyle = this.container.SelectionBasedLifestyle;
// This producer will be automatically registered as external producer.
return(lifestyle.CreateProducer(typeof(TService), item.ImplementationType, this.container));
}
// Note that the 'implementationType' could in fact be a service type as well and it is allowed
// for the implementationType to equal TService. This will happen when someone does the following:
// container.Collections.Register<ILogger>(typeof(ILogger));
private InstanceProducer GetOrCreateInstanceProducer(ContainerControlledItem item)
{
Type implementationType = item.ImplementationType;
// If the implementationType is explicitly registered (using a Register call) we select this
// producer (but we skip any implicit registrations or anything that is assignable, since
// there could be more than one and it would be unclear which one to pick).
InstanceProducer?producer = this.GetExplicitRegisteredInstanceProducer(implementationType);
// If that doesn't result in a producer, we request a registration using unregistered type
// resolution, were we prevent concrete types from being created by the container, since
// the creation of concrete type would 'pollute' the list of registrations, and might result
// in two registrations (since below we need to create a new instance producer out of it),
// and that might cause duplicate diagnostic warnings.
if (producer == null)
{
producer = this.GetInstanceProducerThroughUnregisteredTypeResolution(implementationType);
}
// If that still hasn't resulted in a producer, we create a new producer and return (or throw
// an exception in case the implementation type is not a concrete type).
if (producer == null)
{
return(this.CreateNewExternalProducer(item));
}
// If there is such a producer registered we return a new one with the service type.
// This producer will be automatically registered as external producer.
if (producer.ServiceType == typeof(TService))
{
return(producer);
}
return(new InstanceProducer(typeof(TService),
new ExpressionRegistration(producer.BuildExpression(), this.container)));
}
private Lazy <InstanceProducer> ToLazyInstanceProducer(ContainerControlledItem registration) =>
registration.Registration != null
? ToLazyInstanceProducer(registration.Registration)
: this.ToLazyInstanceProducer(registration.ImplementationType);
void IContainerControlledCollection.Append(ContainerControlledItem registration)
{
this.producers.Add(this.ToLazyInstanceProducer(registration));
}
internal abstract void AddControlledRegistrations(Type serviceType,
ContainerControlledItem[] registrations, bool append);
internal static RegistrationGroup CreateForControlledItems(Type serviceType,
ContainerControlledItem[] registrations, bool appended) =>
new RegistrationGroup
{
ServiceType = serviceType,
ControlledItems = registrations,
Appended = appended
};
private LazyEx <InstanceProducer> ToLazyInstanceProducer(ContainerControlledItem item) =>
item.Registration != null
? ToLazyInstanceProducer(item.Registration)
: new LazyEx <InstanceProducer>(() => this.GetOrCreateInstanceProducer(item));
void IContainerControlledCollection.Append(ContainerControlledItem item)
{
this.producers.Add(this.ToLazyInstanceProducer(item));
}
internal override void AddControlledRegistrations(Type serviceType,
ContainerControlledItem[] registrations, bool append)
{
var group = RegistrationGroup.CreateForControlledItems(serviceType, registrations, append);
this.AddRegistrationGroup(group);
}