private static IEnumerable<InstanceProducer> GetSelfAndDependentProducers(InstanceProducer producer,
HashSet<InstanceProducer> set = null)
{
set = set ?? new HashSet<InstanceProducer>(ReferenceEqualityComparer<InstanceProducer>.Instance);
// Prevent stack overflow exception in case the graph is cyclic.
if (set.Contains(producer))
{
yield break;
}
// Return self
yield return set.AddReturn(producer);
// Return dependent producers
foreach (var relationship in producer.GetRelationships())
{
yield return set.AddReturn(relationship.Dependency);
foreach (var dependentProducer in GetSelfAndDependentProducers(relationship.Dependency, set))
{
yield return set.AddReturn(dependentProducer);
}
}
}
internal DisposableTransientComponentDiagnosticResult(Type serviceType, InstanceProducer registration,
string description)
: base(serviceType, description, DiagnosticType.DisposableTransientComponent,
DiagnosticSeverity.Warning, registration)
{
this.Registration = registration;
}
private void ThrowWhenProviderToRegisterOverlapsWithExistingProvider(
InstanceProducer producerToRegister)
{
// A provider is a superset of the providerToRegister when it can be applied to ALL generic
// types that the providerToRegister can be applied to as well.
var overlappingProducers =
from producer in this.CurrentProducers
where producer.ImplementationType != null
where !producer.Registration.WrapsInstanceCreationDelegate
where !producerToRegister.Registration.WrapsInstanceCreationDelegate
where producer.ImplementationType == producerToRegister.ImplementationType
select producer;
if (overlappingProducers.Any())
{
var overlappingProducer = overlappingProducers.FirstOrDefault();
throw new InvalidOperationException(
StringResources.AnOverlappingGenericRegistrationExists(
producerToRegister.ServiceType,
overlappingProducer.ImplementationType,
overlappingProducer.IsConditional,
producerToRegister.ImplementationType,
producerToRegister.IsConditional));
}
}
internal ServiceTypeDecoratorInfo(Type registeredServiceType, Type implementationType,
InstanceProducer originalProducer)
{
this.registeredServiceType = registeredServiceType;
this.ImplementationType = implementationType;
this.OriginalProducer = originalProducer;
}
private static string BuildDescription(InstanceProducer registration, KnownRelationship[] relationships)
{
string componentName = BuildComponentName(registration, relationships);
string unregisteredTypeName = BuildUnregisteredTypeDescription(relationships);
return componentName + " depends on " + unregisteredTypeName + ".";
}
private static DebuggerViewItem[] GetDebugValue(Type implementationType, InstanceProducer[] dependencies)
{
return new[]
{
new DebuggerViewItem("ImplementationType", implementationType.ToFriendlyName(), implementationType),
new DebuggerViewItem("Dependencies", dependencies.Length + " dependencies.", dependencies),
};
}
private static ContainerRegisteredServiceDiagnosticResult BuildDiagnosticResult(
InstanceProducer registration, KnownRelationship[] relationships)
{
return new ContainerRegisteredServiceDiagnosticResult(
serviceType: registration.ServiceType,
description: BuildDescription(registration, relationships),
relationships: relationships);
}
internal InitializationContext(InstanceProducer producer, Registration registration)
{
// producer will be null when a user calls Registration.BuildExpression() directly, instead of
// calling InstanceProducer.BuildExpression() or InstanceProducer.GetInstance().
Requires.IsNotNull(registration, nameof(registration));
this.Producer = producer;
this.Registration = registration;
}
internal TornLifestyleDiagnosticResult(Type serviceType, string description, Lifestyle lifestyle,
Type implementationType, InstanceProducer[] affectedRegistrations)
: base(serviceType, description, DiagnosticType.TornLifestyle, DiagnosticSeverity.Warning,
CreateDebugValue(implementationType, lifestyle, affectedRegistrations))
{
this.Lifestyle = lifestyle;
this.ImplementationType = implementationType;
this.AffectedRegistrations = new ReadOnlyCollection<InstanceProducer>(affectedRegistrations.ToList());
}
internal ShortCircuitedDependencyDiagnosticResult(Type serviceType, string description,
InstanceProducer registration, KnownRelationship relationship,
IEnumerable<InstanceProducer> expectedDependencies)
: base(serviceType, description, DiagnosticType.ShortCircuitedDependency,
DiagnosticSeverity.Warning,
CreateDebugValue(registration, relationship, expectedDependencies.ToArray()))
{
this.Relationship = relationship;
this.ExpectedDependencies = new ReadOnlyCollection<InstanceProducer>(expectedDependencies.ToList());
}
public void Add(InstanceProducer producer)
{
this.container.ThrowWhenContainerIsLocked();
this.ThrowWhenOverlappingRegistrationsExist(producer);
this.providers.RemoveAll(p => p.ServiceType == producer.ServiceType);
this.providers.Add(new ClosedToInstanceProducerProvider(producer));
}
internal AmbiguousLifestylesDiagnosticResult(Type serviceType, string description,
Lifestyle[] lifestyles, Type implementationType, InstanceProducer diagnosedProducer,
InstanceProducer[] conflictingProducers)
: base(serviceType, description, DiagnosticType.AmbiguousLifestyles, DiagnosticSeverity.Warning,
CreateDebugValue(implementationType, lifestyles, conflictingProducers))
{
this.Lifestyles = new ReadOnlyCollection<Lifestyle>(lifestyles.ToList());
this.ImplementationType = implementationType;
this.DiagnosedRegistration = diagnosedProducer;
this.ConflictingRegistrations = new ReadOnlyCollection<InstanceProducer>(conflictingProducers.ToList());
}
internal void AddAppliedDecorator(Type decoratorType, Container container, Lifestyle lifestyle,
Expression decoratedExpression, IEnumerable<KnownRelationship> decoratorRelationships = null)
{
var registration = new ExpressionRegistration(decoratedExpression, decoratorType,
lifestyle, container);
registration.ReplaceRelationships(decoratorRelationships ?? Enumerable.Empty<KnownRelationship>());
var producer = new InstanceProducer(this.registeredServiceType, registration);
this.appliedDecorators.Add(new DecoratorInfo(decoratorType, producer));
}
private static TornLifestyleDiagnosticResult CreateDiagnosticResult(
InstanceProducer diagnosedProducer,
InstanceProducer[] affectedProducers)
{
Type serviceType = diagnosedProducer.ServiceType;
Type implementationType = diagnosedProducer.Registration.ImplementationType;
Lifestyle lifestyle = diagnosedProducer.Registration.Lifestyle;
string description = BuildDescription(diagnosedProducer, affectedProducers);
return new TornLifestyleDiagnosticResult(serviceType, description, lifestyle, implementationType,
affectedProducers);
}
public void Add(InstanceProducer producer)
{
this.container.ThrowWhenContainerIsLocked();
this.ThrowWhenConditionalIsRegisteredInOverridingMode(producer);
this.ThrowWhenOverlappingRegistrationsExist(producer);
if (this.container.Options.AllowOverridingRegistrations)
{
this.providers.RemoveAll(p => p.ServiceType == producer.ServiceType);
}
this.providers.Add(new ClosedToInstanceProducerProvider(producer));
}
public void Add(InstanceProducer producer)
{
this.container.ThrowWhenContainerIsLocked();
this.ThrowWhenConditionalAndUnconditionalAreMixed(producer);
this.ThrowWhenTypeAlreadyRegistered(producer);
if (producer.IsUnconditional)
{
this.producers.Clear();
}
this.producers.Add(producer);
}
private static bool IsAnalyzable(InstanceProducer producer)
{
// We can't analyze collections, because this would lead to false positives when decorators are
// applied to the collection. For a decorator, each collection element it decorates is a
// dependency, which will make it look as if the decorator has too many dependencies. Since the
// container will delegate the creation of those elements back to the container, those elements
// would by them selves still get analyzed, so the only thing we'd miss here is the decorator.
if (!producer.ServiceType.Info().IsGenericType)
{
return true;
}
return producer.ServiceType.GetGenericTypeDefinition() != typeof(IEnumerable<>);
}
internal OverriddenParameter(ParameterInfo parameter, Expression expression, InstanceProducer producer)
{
this.Parameter = parameter;
this.Expression = expression;
this.Producer = producer;
// A placeholder is a fake expression that we inject into the NewExpression. After the
// NewExpression is created, it is ran through the ExpressionBuilding interception. By using
// placeholders instead of the real overridden expressions we prevent those expressions from
// being processed twice by the ExpressionBuilding event (since we expect the supplied expressions
// to already be processed). After the event has ran we replace the placeholders with the real
// expressions again (using an ExpressionVisitor).
this.PlaceHolder = System.Linq.Expressions.Expression.Constant(null, parameter.ParameterType);
}
public void Add(InstanceProducer producer)
{
this.container.ThrowWhenContainerIsLocked();
this.ThrowWhenConditionalAndUnconditionalAreMixed(producer);
this.ThrowWhenTypeAlreadyRegistered(producer);
this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(producer);
if (producer.IsUnconditional)
{
this.providers.Clear();
}
this.providers.Add(new SingleInstanceProducerProvider(producer));
}
public void Add(InstanceProducer producer)
{
this.container.ThrowWhenContainerIsLocked();
this.ThrowWhenConditionalAndUnconditionalAreMixed(producer);
this.ThrowWhenConditionalIsRegisteredInOverridingMode(producer);
this.ThrowWhenTypeAlreadyRegistered(producer);
this.ThrowWhenIdenticalImplementationIsAlreadyRegistered(producer);
if (producer.IsUnconditional)
{
this.providers.Clear();
}
this.providers.Add(new SingleInstanceProducerProvider(producer));
}
internal static IRegistrationEntry Create(InstanceProducer producer)
{
if (producer.ServiceType.IsGenericType)
{
var entry = new GenericRegistrationEntry(
producer.ServiceType.GetGenericTypeDefinition(),
producer.Registration.Container);
entry.Add(producer);
return entry;
}
else
{
return new NonGenericRegistrationEntry(producer);
}
}
private static DebuggerViewItem[] CreateDebugValue(Type implementationType, Lifestyle lifestyle,
InstanceProducer[] affectedRegistrations)
{
return new[]
{
new DebuggerViewItem(
name: "ImplementationType",
description: implementationType.ToFriendlyName(),
value: implementationType),
new DebuggerViewItem(
name: "Lifestyle",
description: lifestyle.Name,
value: lifestyle),
new DebuggerViewItem(
name: "Affected Registrations",
description: ToCommaSeparatedText(affectedRegistrations),
value: affectedRegistrations)
};
}
private static DebuggerViewItem[] CreateDebugValue(Type implementationType, Lifestyle[] lifestyles,
InstanceProducer[] conflictingRegistrations)
{
return new[]
{
new DebuggerViewItem(
name: "ImplementationType",
description: implementationType.ToFriendlyName(),
value: implementationType),
new DebuggerViewItem(
name: "Lifestyles",
description: ToCommaSeparatedText(lifestyles),
value: lifestyles),
new DebuggerViewItem(
name: "Conflicting Registrations",
description: ToCommaSeparatedText(conflictingRegistrations),
value: conflictingRegistrations)
};
}
private static DebuggerViewItem[] CreateDebugValue(InstanceProducer registration,
KnownRelationship actualDependency,
InstanceProducer[] possibleSkippedRegistrations)
{
return new[]
{
new DebuggerViewItem(
name: "Registration",
description: registration.ServiceType.ToFriendlyName(),
value: registration),
new DebuggerViewItem(
name: "Actual Dependency",
description: actualDependency.Dependency.ServiceType.ToFriendlyName(),
value: actualDependency),
new DebuggerViewItem(
name: "Expected Dependency",
description: possibleSkippedRegistrations.First().ServiceType.ToFriendlyName(),
value: possibleSkippedRegistrations.Length == 1 ?
(object)possibleSkippedRegistrations[0] :
possibleSkippedRegistrations),
};
}
/// <summary>
/// Allows the resolving function factories.
/// </summary>
/// <param name="options">The options.</param>
public static void AllowResolvingFuncFactories(this ContainerOptions options)
{
options.Container.ResolveUnregisteredType += (s, e) => {
var type = e.UnregisteredServiceType;
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Func <>))
{
return;
}
Type serviceType = type.GetGenericArguments().First();
InstanceProducer registration =
options.Container.GetRegistration(serviceType, true);
Type funcType = typeof(Func <>).MakeGenericType(serviceType);
var factoryDelegate = Expression.Lambda(funcType,
registration.BuildExpression()).Compile();
e.Register(Expression.Constant(factoryDelegate));
};
}
InstanceProducer IDependencyInjectionBehavior.GetInstanceProducer(
InjectionConsumerInfo consumer, bool throwOnFailure)
{
ThreadLocal <object> local = this.FindThreadLocal(consumer.Target);
if (local != null)
{
if (consumer.Target.TargetType.IsValueType && this.container.IsVerifying())
{
throw new InvalidOperationException(
"You can't use Verify() if the factory product contains value types.");
}
return(InstanceProducer.FromExpression(
consumer.Target.TargetType,
Expression.Convert(
Expression.Property(Expression.Constant(local), "Value"),
consumer.Target.TargetType),
this.container));
}
return(this.originalBehavior.GetInstanceProducer(consumer, throwOnFailure));
}
private OverriddenParameter[] CreateOverriddenParameters(
Type serviceType,
ConstructorInfo decoratorConstructor,
Expression decorateeExpression,
InstanceProducer realProducer,
ServiceTypeDecoratorInfo info)
{
ParameterInfo decorateeParameter = GetDecorateeParameter(serviceType, decoratorConstructor);
decorateeExpression = this.GetExpressionForDecorateeDependencyParameterOrNull(
decorateeParameter, serviceType, decorateeExpression);
var currentProducer = info.GetCurrentInstanceProducer();
if (DecoratorHelpers.IsDecorateeFactoryDependencyType(decorateeParameter.ParameterType, serviceType))
{
// Adding a verifier makes sure the graph for the decoratee gets created,
// which allows testing whether constructing the graph fails.
AddVerifierForDecorateeFactoryDependency(decorateeExpression, realProducer);
// By adding the decoratee producer, we allow that object graph to be diagnosed.
realProducer.AddProducerToVerify(currentProducer);
currentProducer = this.CreateDecorateeFactoryProducer(decorateeParameter);
}
var decorateeOverriddenParameter =
new OverriddenParameter(decorateeParameter, decorateeExpression, currentProducer);
IEnumerable <OverriddenParameter> predicateContextOverriddenParameters =
this.CreateOverriddenDecoratorContextParameters(decoratorConstructor, currentProducer);
var overriddenParameters = (new[] { decorateeOverriddenParameter })
.Concat(predicateContextOverriddenParameters);
return(overriddenParameters.ToArray());
}
private void ThrowWhenOverlappingRegistrationsExist(InstanceProducer producerToRegister)
{
if (!this.container.Options.AllowOverridingRegistrations)
{
var overlappingProviders =
from provider in this.providers
where provider.OverlapsWith(producerToRegister)
select provider;
if (overlappingProviders.Any())
{
var overlappingProvider = overlappingProviders.First();
if (overlappingProvider.ServiceType.IsGenericTypeDefinition())
{
// An overlapping provider will always have an ImplementationType, because providers
// with a factory will never be overlapping.
Type implementationType = overlappingProvider.ImplementationType !;
throw new InvalidOperationException(
StringResources.RegistrationForClosedServiceTypeOverlapsWithOpenGenericRegistration(
producerToRegister.ServiceType,
implementationType));
}
bool eitherOneRegistrationIsConditional =
overlappingProvider.IsConditional != producerToRegister.IsConditional;
throw eitherOneRegistrationIsConditional
? GetAnOverlappingGenericRegistrationExistsException(
new ClosedToInstanceProducerProvider(producerToRegister),
overlappingProvider)
: new InvalidOperationException(
StringResources.TypeAlreadyRegistered(producerToRegister.ServiceType));
}
}
}
private static IEnumerable <InstanceProducer> GetSelfAndDependentProducers(InstanceProducer producer,
HashSet <InstanceProducer> set)
{
// Prevent stack overflow exception in case the graph is cyclic.
if (set.Contains(producer))
{
yield break;
}
// Return self
yield return(set.AddReturn(producer));
// Return dependent producers
foreach (var relationship in producer.GetRelationships())
{
if (relationship.UseForVerification)
{
foreach (var dependentProducer in GetSelfAndDependentProducers(relationship.Dependency, set))
{
yield return(set.AddReturn(dependentProducer));
}
}
}
}
private InstanceProducer GetInstanceProducerFor(ParameterInfo parameter)
{
InstanceProducer producer = null;
Container container = this.getContainer();
if (container == null)
{
throw new InvalidOperationException(
StringResources.CanNotCallBuildParameterExpressionContainerOptionsNotPartOfContainer());
}
producer = container.GetRegistrationEvenIfInvalid(parameter.ParameterType);
if (producer == null)
{
container.Options.ConstructorVerificationBehavior.Verify(parameter);
throw new ActivationException(StringResources.ParameterTypeMustBeRegistered(
parameter.Member.DeclaringType, parameter));
}
return(producer);
}
private InstanceProducer?TryGetProducerFromUnregisteredTypeResolutionCacheOrAdd(
UnregisteredTypeEventArgs e)
{
lock (this.resolveUnregisteredTypeRegistrations)
{
if (this.resolveUnregisteredTypeRegistrations.ContainsKey(e.UnregisteredServiceType))
{
// This line will only get hit, in case a different thread came here first.
return(this.resolveUnregisteredTypeRegistrations[e.UnregisteredServiceType].Value);
}
var registration = e.Registration ?? new ExpressionRegistration(e.Expression !, this.container);
// By creating the InstanceProducer after checking the dictionary, we prevent the producer
// from being created twice when multiple threads are running. Having the same duplicate
// producer can cause a torn lifestyle warning in the container.
var producer = new InstanceProducer(e.UnregisteredServiceType, registration);
this.resolveUnregisteredTypeRegistrations[e.UnregisteredServiceType] =
Helpers.ToLazy(producer);
return(producer);
}
}
public void AddRegistration(Type serviceType, Registration registration, string name)
{
if (this.IsLocked())
{
throw new InvalidOperationException("The container is locked.");
}
Dictionary <string, InstanceProducer> dict;
if (!this.namedProducers.TryGetValue(serviceType, out dict))
{
dict = new Dictionary <string, InstanceProducer>();
this.namedProducers[serviceType] = dict;
}
if (this.Options.AllowOverridingRegistrations)
{
dict[name] = new InstanceProducer(serviceType, registration);
}
else
{
dict.Add(name, new InstanceProducer(serviceType, registration));
}
}
private static void BuildDependencies(Container container, InstanceProducer producer, List <DependencyInfo> acc, HashSet <InstanceProducer> visited)
{
if (visited.Contains(producer))
{
return;
}
visited.Add(producer);
foreach (var rel in producer.GetRelationships())
{
var child = rel.Dependency.Registration.ImplementationType;
if (child.IsArray)
{
var interfaceType = child.GetElementType();
foreach (var dep in container.GetAllInstances(interfaceType))
{
acc.Add(new DependencyInfo(producer.ServiceType, dep.GetType(), interfaceType));
BuildDependencies(container, dep.GetType(), acc, visited);
}
}
else if (child.IsGenericType && child.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
var interfaceType = child.GetGenericArguments()[0];
foreach (var dep in container.GetAllInstances(interfaceType))
{
acc.Add(new DependencyInfo(producer.ServiceType, dep.GetType(), interfaceType));
BuildDependencies(container, dep.GetType(), acc, visited);
}
}
else
{
acc.Add(new DependencyInfo(producer.Registration.ImplementationType, rel.Dependency.Registration.ImplementationType, rel.Dependency.ServiceType));
BuildDependencies(container, rel.Dependency, acc, visited);
}
}
}
private static string BuildDescription(InstanceProducer diagnosedProducer,
InstanceProducer[] affectedProducers)
{
Lifestyle lifestyle = diagnosedProducer.Registration.Lifestyle;
var tornProducers = (
from producer in affectedProducers
where producer.Registration != diagnosedProducer.Registration
select producer)
.ToArray();
return(string.Format(CultureInfo.InvariantCulture,
"The registration for {0} maps to the same implementation and lifestyle as the {1} " +
"for {2} {3}. They {4} map to {5} ({6}). This will cause each registration to resolve to " +
"a different instance: each registration will have its own instance{7}.",
diagnosedProducer.ServiceType.ToFriendlyName(),
tornProducers.Length == 1 ? "registration" : "registrations",
tornProducers.Select(producer => producer.ServiceType.ToFriendlyName()).ToCommaSeparatedText(),
tornProducers.Length == 1 ? "does" : "do",
tornProducers.Length == 1 ? "both" : "all",
diagnosedProducer.Registration.ImplementationType.ToFriendlyName(),
lifestyle.Name,
lifestyle == Lifestyle.Singleton ? string.Empty : " during a single " + lifestyle.Name));
}
private static DebuggerViewItem BuildNonGenericGroup(Type closedType,
InstanceProducer[] producersForGroup)
{
return new DebuggerViewItem(
name: Helpers.ToFriendlyName(closedType),
description: "Count = " + producersForGroup.Length,
value: producersForGroup.ToArray());
}
private object BuildGenericGroup(Type groupType,
InstanceProducer[] producersForGroup, int level)
{
object[] childGroups = this.GroupProducers(producersForGroup, level);
if (childGroups.Length == 1)
{
// This flattens the hierarchy when there is just one item in the group.
return childGroups[0];
}
return new DebuggerViewItem(
name: Helpers.ToFriendlyName(groupType),
description: "Count = " + producersForGroup.Length,
value: childGroups);
}
private object BuildProducerGroup(Type groupType,
InstanceProducer[] producersForGroup, int level)
{
if (producersForGroup.Length == 1)
{
var producer = producersForGroup[0];
// This flattens the hierarchy when there is just one item in the group.
return new DebuggerViewItem(
name: Helpers.ToFriendlyName(producer.ServiceType),
description: producer.DebuggerDisplay,
value: producersForGroup[0]);
}
if (groupType.ContainsGenericParameters)
{
return this.BuildGenericGroup(groupType, producersForGroup, level);
}
else
{
return BuildNonGenericGroup(groupType, producersForGroup);
}
}
private IEnumerable <OverriddenParameter> CreateOverriddenDecoratorContextParameters(
InstanceProducer currentProducer) =>
from parameter in this.decoratorConstructor !.GetParameters()
internal static bool IsContainerControlledCollection(this InstanceProducer producer) => IsContainerControlledCollection(producer.Registration);
internal CyclicDependencyValidator(InstanceProducer producer)
{
this.producer = producer;
}
internal DisposableTransientComponentDiagnosticResult(Type serviceType, InstanceProducer registration,
string description)
: base(serviceType, description, DiagnosticType.DisposableTransientComponent, registration)
{
}
internal AmbiguousLifestylesDiagnosticResult(Type serviceType, string description,
Lifestyle[] lifestyles, Type implementationType, InstanceProducer diagnosedProducer,
InstanceProducer[] conflictingProducers)
: base(serviceType, description, DiagnosticType.AmbiguousLifestyles,
CreateDebugValue(implementationType, lifestyles, conflictingProducers))
{
this.Lifestyles = new ReadOnlyCollection <Lifestyle>(lifestyles.ToList());
this.ImplementationType = implementationType;
this.DiagnosedRegistration = diagnosedProducer;
this.ConflictingRegistrations = new ReadOnlyCollection <InstanceProducer>(conflictingProducers.ToList());
}
public FoundInstanceProducer(Type serviceType, Type implementationType, InstanceProducer producer)
{
this.ServiceType = serviceType;
this.ImplementationType = implementationType;
this.Producer = producer;
}
public bool OverlapsWith(InstanceProducer producerToCheck) =>
this.IsConditional || this.ImplementationType == null
? false // Conditionals never overlap compile time.
: GenericTypeBuilder.IsImplementationApplicableToEveryGenericType(
producerToCheck.ServiceType,
this.ImplementationType);
public bool OverlapsWith(InstanceProducer producerToCheck) => (this.producer.IsUnconditional || producerToCheck.IsUnconditional) && this.producer.ServiceType == producerToCheck.ServiceType;
internal static Type GetContainerControlledCollectionElementType(this InstanceProducer producer) => ((ContainerControlledCollectionRegistration)producer.Registration).ElementType;
internal DecoratorInfo(Type decoratorType, InstanceProducer decoratorProducer)
{
this.DecoratorType = decoratorType;
this.DecoratorProducer = decoratorProducer;
}
internal ServiceTypeDecoratorInfo(Type implementationType, InstanceProducer originalProducer)
{
this.ImplementationType = implementationType;
this.OriginalProducer = originalProducer;
}
private static string BuildDescription(InstanceProducer producer) =>
string.Format(
CultureInfo.InvariantCulture,
"{0} is registered as transient, but implements IDisposable.",
producer.Registration.ImplementationType.ToFriendlyName());
internal override void RegisterUncontrolledCollection(Type serviceType, InstanceProducer producer)
{
this.AddRegistrationGroup(RegistrationGroup.CreateForUncontrolledProducer(serviceType, producer));
}
internal abstract void RegisterUncontrolledCollection(Type serviceType, InstanceProducer producer);
private static string ToFriendlyNameWithLifestyle(InstanceProducer producer) =>
producer.ServiceType.FriendlyName() + " (" + producer.Registration.Lifestyle.Name + ")";
private void ThrowWhenConditionalAndUnconditionalAreMixed(InstanceProducer producer)
{
this.ThrowWhenNonGenericTypeAlreadyRegisteredAsUnconditionalRegistration(producer);
this.ThrowWhenNonGenericTypeAlreadyRegisteredAsConditionalRegistration(producer);
}
public SingleInstanceProducerProvider(InstanceProducer producer) => this.producer = producer;
private void ThrowWhenOverlappingRegistrationsExist(InstanceProducer producer)
{
if (!this.container.Options.AllowOverridingRegistrations)
{
var overlappingProviders =
from provider in this.providers
where provider.OverlapsWith(producer.ServiceType)
select provider;
if (overlappingProviders.Any())
{
var overlappingProvider = overlappingProviders.First();
if (overlappingProvider.ServiceType.IsGenericTypeDefinition)
{
throw new InvalidOperationException(
StringResources.RegistrationForClosedServiceTypeOverlapsWithOpenGenericRegistration(
producer.ServiceType,
overlappingProvider.ImplementationType));
}
throw new InvalidOperationException(StringResources.TypeAlreadyRegistered(producer.ServiceType));
}
}
}
internal override void RegisterUncontrolledCollection(Type serviceType, InstanceProducer producer)
{
throw new NotSupportedException(
StringResources.MixingRegistrationsWithControlledAndUncontrolledIsNotSupported(serviceType,
controlled: false));
}
private IEnumerable<OverriddenParameter> CreateOverriddenDecoratorContextParameters(
InstanceProducer currentProducer)
{
return
from parameter in this.decoratorConstructor.GetParameters()
where parameter.ParameterType == typeof(DecoratorContext)
let contextExpression = Expression.Constant(new DecoratorContext(this.Context))
select new OverriddenParameter(parameter, contextExpression, currentProducer);
}
public ClosedToInstanceProducerProvider(InstanceProducer producer)
{
this.producer = producer;
}
public ClosedToInstanceProducerProvider(InstanceProducer producer)
{
this.producer = producer;
}
private static ContainerRegisteredServiceDiagnosticResult BuildDiagnosticResult(
InstanceProducer registration, KnownRelationship[] relationships) =>
new ContainerRegisteredServiceDiagnosticResult(
serviceType: registration.ServiceType,
description: BuildDescription(registration, relationships),
relationships: relationships);
