private void AddDependencyInfoToDictionary(RegisteredDependencyInfo dependencyInfo)
{
List <ImplementationData> implementationDatas;
if (dependencyToImplementations.ContainsKey(dependencyInfo.DependencyType))
{
implementationDatas = dependencyToImplementations[dependencyInfo.DependencyType];
}
else
{
implementationDatas = new List <ImplementationData>();
dependencyToImplementations.Add(dependencyInfo.DependencyType, implementationDatas);
}
IImplementationCreator?provider = null;
switch (dependencyInfo.Lifetime)
{
case Lifetime.Instance:
provider = CreateTransientProvider(dependencyInfo.ImplementationType);
break;
case Lifetime.Singleton:
provider = CreateSingletonProvider(dependencyInfo.ImplementationType);
break;
}
if (provider != null)
{
implementationDatas.Add(new ImplementationData(provider, dependencyInfo.DependencyType,
dependencyInfo.ImplementationType, dependencyInfo.Name));
}
}
private RegisteredDependencyInfo CreateOpenGenericInfoCopy(RegisteredDependencyInfo dependencyInfo,
Type[] genericDependencyType)
{
return(new RegisteredDependencyInfo(
dependencyInfo.DependencyType.MakeGenericType(genericDependencyType),
dependencyInfo.ImplementationType.MakeGenericType(genericDependencyType),
dependencyInfo.Lifetime,
dependencyInfo.Name
));
}
private void privateRegister(Type dependency, Type implementation, Lifetime lifetime, object?name)
{
ValidateNotAbstract(implementation);
ValidateConstructors(implementation);
RegisteredDependencyInfo dependencyInfo = new RegisteredDependencyInfo(dependency, implementation, lifetime, name);
if (!RegisteredDependencies.ContainsKey(dependency))
{
RegisteredDependencies.Add(dependency, new List <RegisteredDependencyInfo>()
{
dependencyInfo
});
}
else
{
List <RegisteredDependencyInfo> dependencyInfos = RegisteredDependencies[dependency];
ValidateNotImplDuplication(dependencyInfos, implementation, dependencyInfo.Name);
dependencyInfos.Add(dependencyInfo);
}
}
