public static ProfileResolver Find(
ResolveContext context,
DependencyRegistration reg)
{
return(Simple.Find(reg)
?? Func.Find(context, reg));
}
public object CreateObject(DependencyRegistration registration)
{
StringBuilder unresolvedDependenciesMessage = null;
foreach (var constructor in registration.Constructors)
{
var unresolvedDependencies = new List <ParameterInfo>();
var dependents = constructor.Value
.Select(pi =>
{
var success = ResolveContext.TryResolve(pi.ParameterType, out var instance);
if (!success)
{
unresolvedDependencies.Add(pi);
}
return(instance);
}).ToArray();
if (unresolvedDependencies.Any() == false)
{
return(AssignProperties(constructor.Key.Invoke(dependents)));
}
LogUnresolvedConstructor(unresolvedDependencies, ref unresolvedDependenciesMessage);
}
throw new DependencyResolutionException(
$"Could not resolve type {registration.ConcreteType.Name} because its dependencies couldn't be fullfilled\r\n{unresolvedDependenciesMessage}");
}
public object CreateObject(DependencyRegistration registration)
{
StringBuilder unresolvedDependenciesMessage = null;
foreach (var constructor in registration.Constructors)
{
var unresolvedDependencies = constructor.Value.Aggregate(new List <ParameterInfo>(),
(unresolved, pi) =>
{
if (
!ResolveContext.Registrations.HasRegistrationForService(
pi.ParameterType))
{
unresolved.Add(pi);
}
return(unresolved);
});
if (unresolvedDependencies.Count > 0)
{
LogUnresolvedConstructor(unresolvedDependencies, ref unresolvedDependenciesMessage);
continue;
}
var dependents = from pi in constructor.Value
select ResolveContext.Resolve(pi.ParameterType);
return(AssignProperties(constructor.Key.Invoke(dependents.ToArray())));
}
throw new DependencyResolutionException(
"Could not resolve type {0} because its dependencies couldn't be fullfilled\r\n{1}".With(registration.ConcreteType.Name, unresolvedDependenciesMessage));
}
public override object Resolve(ResolveContext context, DependencyRegistration registration)
{
var lazy = _instances
.GetOrAdd(registration.Key, key => ThreadSafeLazyFactory(context, registration));
return(lazy.Value);
}
public object CreateObject(DependencyRegistration registration)
{
StringBuilder unresolvedDependenciesMessage = null;
foreach (var constructor in registration.Constructors)
{
var unresolvedDependencies = constructor.Value.Aggregate(new List<ParameterInfo>(),
(unresolved, pi) =>
{
if (
!ResolveContext.Registrations.HasRegistrationForService(
pi.ParameterType))
unresolved.Add(pi);
return unresolved;
});
if (unresolvedDependencies.Count > 0)
{
LogUnresolvedConstructor(unresolvedDependencies, ref unresolvedDependenciesMessage);
continue;
}
var dependents = from pi in constructor.Value
select ResolveContext.Resolve(pi.ParameterType);
return AssignProperties(constructor.Key.Invoke(dependents.ToArray()));
}
throw new DependencyResolutionException(
"Could not resolve type {0} because its dependencies couldn't be fullfilled\r\n{1}".With(registration.ConcreteType.Name, unresolvedDependenciesMessage));
}
public void Add(DependencyRegistration registration)
{
registration.LifetimeManager.VerifyRegistration(registration);
lock (_registrations)
{
GetSvcRegistrations(registration.ServiceType).Add(registration);
}
}
public void Add(DependencyRegistration registration)
{
registration.LifetimeManager.VerifyRegistration(registration);
lock (_registrations)
{
GetSvcRegistrations(registration.ServiceType).Add(registration);
}
}
public static ProfileResolver Find(DependencyRegistration reg)
{
bool tryResolve(IDependencyRegistrationCollection registrations, ResolveContext context, out object instance)
=> context.TryResolve(reg, out instance);
if (reg != null)
{
return(tryResolve);
}
return(null);
}
public override bool IsRegistrationAvailable(DependencyRegistration registration)
{
if (!Resolver.HasDependency(typeof(IContextStore))) return false;
if (!registration.IsInstanceRegistration)
return true;
var store = Resolver.Resolve<IContextStore>();
bool storeHasRegistration = store.GetContextInstances().Any(x => x.Key == registration.Key);
return storeHasRegistration;
}
public override object Resolve(ResolveContext context, DependencyRegistration registration)
{
if (!_resolver.TryResolve <IContextStore>(out var store))
{
throw new DependencyResolutionException(
"Could not resolve the context store. Make sure you have registered one.");
}
return(store
.GetConcurrentContextInstances()
.GetOrAdd(registration, reg => reg.Factory(context)));
}
public override object Resolve(ResolveContext context, DependencyRegistration registration)
{
object instance;
if (!_instances.TryGetValue(registration.Key, out instance))
lock (_instances)
{
if (!_instances.TryGetValue(registration.Key, out instance))
_instances.Add(registration.Key, instance = base.Resolve(context, registration));
}
return instance;
}
public override void VerifyRegistration(DependencyRegistration registration)
{
if (registration.IsInstanceRegistration)
{
if (_instances[registration.Key] != null)
throw new InvalidOperationException("Trying to register an instance for a registration that already has one.");
lock (_instances)
{
_instances[registration.Key] = registration.Instance;
}
registration.Instance = null;
}
}
public override void VerifyRegistration(DependencyRegistration registration)
{
if (registration.RegistrationKind == RegistrationKind.Instance)
{
CheckContextStoreAvailable();
var instance = registration.Instance;
registration.Instance = null;
var store = Resolver.Resolve<IContextStore>();
if (store[registration.Key] != null)
throw new DependencyResolutionException("An instance is being registered for an existing registration.");
StoreInstanceInContext(store, registration.Key, instance);
}
}
public object Resolve(DependencyRegistration registration)
{
if (_recursionDefender.Contains(registration))
throw new InvalidOperationException("Recursive dependencies are not allowed.");
try
{
_recursionDefender.Push(registration);
return registration.LifetimeManager.Resolve(this, registration);
}
finally
{
_recursionDefender.Pop();
}
}
public override void VerifyRegistration(DependencyRegistration registration)
{
if (registration.IsInstanceRegistration)
{
if (_instances[registration.Key] != null)
{
throw new InvalidOperationException("Trying to register an instance for a registration that already has one.");
}
lock (_instances)
{
_instances[registration.Key] = registration.Instance;
}
registration.Instance = null;
}
}
public override object Resolve(ResolveContext context, DependencyRegistration registration)
{
object instance;
if (!_instances.TryGetValue(registration.Key, out instance))
{
lock (_instances)
{
if (!_instances.TryGetValue(registration.Key, out instance))
{
_instances.Add(registration.Key, instance = base.Resolve(context, registration));
}
}
}
return(instance);
}
public override void VerifyRegistration(DependencyRegistration registration)
{
if (registration.IsInstanceRegistration)
{
CheckContextStoreAvailable();
var instance = registration.Instance;
registration.Instance = null;
var store = Resolver.Resolve <IContextStore>();
if (store[registration.Key] != null)
{
throw new DependencyResolutionException("An instance is being registered for an existing registration.");
}
StoreInstanceInContext(store, registration.Key, instance);
}
}
public object Resolve(DependencyRegistration registration)
{
if (_recursionDefender.Contains(registration))
{
throw new InvalidOperationException("Recursive dependencies are not allowed.");
}
try
{
_recursionDefender.Push(registration);
return(registration.LifetimeManager.Resolve(this, registration));
}
finally
{
_recursionDefender.Pop();
}
}
public override bool IsRegistrationAvailable(DependencyRegistration registration)
{
if (!Resolver.HasDependency(typeof(IContextStore)))
{
return(false);
}
if (!registration.IsInstanceRegistration)
{
return(true);
}
var store = Resolver.Resolve <IContextStore>();
bool storeHasRegistration = store.GetContextInstances().Any(x => x.Key == registration.Key);
return(storeHasRegistration);
}
public bool TryResolve(DependencyRegistration registration, out object instance)
{
instance = null;
if (_recursionDefender.Contains(registration))
{
return(false);
}
try
{
_recursionDefender.Push(registration);
instance = registration.ResolveInContext(this);
return(true);
}
finally
{
_recursionDefender.Pop();
}
}
public override object Resolve(ResolveContext context, DependencyRegistration registration)
{
CheckContextStoreAvailable();
object instance;
var contextStore = Resolver.Resolve<IContextStore>();
if ((instance = contextStore[registration.Key]) == null)
{
if (registration.RegistrationKind == RegistrationKind.Instance)
throw new DependencyResolutionException("A dependency registered as an instance wasn't found. The registration was removed.");
instance = base.Resolve(context, registration);
StoreInstanceInContext(contextStore, registration.Key, instance);
}
return instance;
}
public override object Resolve(ResolveContext context, DependencyRegistration registration)
{
CheckContextStoreAvailable();
object instance;
var contextStore = Resolver.Resolve <IContextStore>();
if ((instance = contextStore[registration.Key]) == null)
{
if (registration.IsInstanceRegistration)
{
throw new DependencyResolutionException("A dependency registered as an instance wasn't found. The registration was removed.");
}
instance = base.Resolve(context, registration);
StoreInstanceInContext(contextStore, registration.Key, instance);
}
return(instance);
}
public static ProfileResolver Find(ResolveContext context, DependencyRegistration registration)
{
var serviceType = registration.ServiceType;
if (serviceType.IsGenericType == false ||
serviceType.GetGenericTypeDefinition() != typeof(Func <>))
{
return(null);
}
var innerType = serviceType.GetGenericArguments()[0];
var innerProfile = ResolveProfiles.Find(context, registration);
ProfileResolver getTypedResolver(ProfileResolver resolver)
{
var profile =
(ResolveProfile)Activator.CreateInstance(typeof(FuncProfile <>).MakeGenericType(innerType), innerProfile);
return(profile.TryResolve);
}
return(innerProfile != null?getTypedResolver(innerProfile) : null);
}
public virtual bool IsRegistrationAvailable(DependencyRegistration registration)
{
return true;
}
public virtual object Resolve(ResolveContext context, DependencyRegistration registration)
{
return context.Builder.CreateObject(registration);
}
static Lazy <object> ThreadSafeLazyFactory(ResolveContext context, DependencyRegistration registration)
{
return(new Lazy <object>(() => registration.Factory(context), LazyThreadSafetyMode.ExecutionAndPublication));
}
public void Add(DependencyRegistration registration)
{
_registrations.Push(registration);
Last = registration;
}
public void Add(DependencyRegistration registration)
{
var bag = _registrations.GetOrAdd(registration.ServiceType, type => new RegistrationBag());
bag.Add(registration.OverrideLifetimeManager(_lifetimes[registration.Lifetime]));
}
public bool CanResolve(DependencyRegistration registration)
{
return !this.recursionDefender.Contains(registration);
}
public void Add(DependencyRegistration registration)
{
_registrations
.GetOrAdd(registration.ServiceType, t => new RegistrationBag())
.Add(registration);
}
public object Resolve(DependencyRegistration registration)
{
return(TryResolve(registration, out var instance)
? instance
: throw new InvalidOperationException("Recursive dependencies are not allowed."));
}
public bool CanResolve(DependencyRegistration registration)
{
return(!_recursionDefender.Contains(registration));
}
public virtual void VerifyRegistration(DependencyRegistration registration)
{
}