public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var contractGenericArgs = contract.GenericTypeArguments;
var notificationType = contractGenericArgs[0];
var processorType = typeof(INotificationProcessor <>).MakeGenericType(contractGenericArgs);
var dependencies = engine.GetApplicable(processorType);
var dependenciesLength = dependencies.Length;
var pipelineType = dependenciesLength switch
{
0 => throw Error.DependencyNotRegistered(processorType),
1 => typeof(NotificationSimplePipeline <>),
_ => ParallelAttribute.IsDefined(notificationType)
? typeof(NotificationParallelPipeline <>)
: typeof(NotificationSequentialPipeline <>)
};
var implementation = pipelineType.MakeGenericType(contractGenericArgs);
var lifetime = dependencies.DefineLifetime();
var resolver = DependencyResolver.Build(lifetime, implementation);
return(Dependency.Build(lifetime, new[] { contract }, resolver));
}
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var writers = engine.GetApplicable(typeof(ILogWriter));
var contracts = new[] { _providerType };
if (writers.Length == 0)
{
return(new InstanceDependency(contracts, new NullProvider()));
}
var resolver = new CompiledResolver(typeof(LogProvider), engine);
return(Dependency.Build(DependencyLifetime.Scoped, contracts, resolver));
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var systemType = contract.GenericTypeArguments[0];
var dependencies = engine.GetApplicable(systemType);
var contracts = new[] { contract };
if (dependencies.Length == 0)
{
var nullHandlerType = typeof(SystemNullPipeline <>).MakeGenericType(systemType);
var nullHandler = Activator.CreateInstance(nullHandlerType);
return(new InstanceDependency(contracts, nullHandler));
}
var handlerType = DefineHandlerType(dependencies);
var implementation = handlerType.MakeGenericType(systemType);
var lifetime = dependencies.DefineLifetime();
var resolver = DependencyResolver.Build(lifetime, implementation);
return(Dependency.Build(lifetime, contracts, resolver));
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var elementType = contract.IsArray
? ReflectionUtils.GetArrayElementType(contract)
: contract.GenericTypeArguments[0];
var contracts = new[] { elementType.MakeArrayType(), _enumerableType.MakeGenericType(elementType) };
var dependencies = engine.GetApplicable(elementType);
if (dependencies.Length == 0)
{
var emptyDependencyType = typeof(EmptyArrayDependency <>).MakeGenericType(elementType);
return((IDependency)Activator.CreateInstance(emptyDependencyType));
}
var resolverType = typeof(ArrayResolver <>).MakeGenericType(elementType);
var resolverParameters = new object[] { dependencies };
var resolver = (DependencyResolver)Activator.CreateInstance(resolverType, resolverParameters);
var lifetime = dependencies.DefineLifetime();
return(Dependency.Build(lifetime, contracts, resolver));
}
