private void InitializeRootRegistry()
{
Register = AddOrReplace;
// Create Registry and set Factory strategy
_metadata = new Registry <Type, int[]>();
_registry = new Registry <NamedType, IPolicySet>(new DefaultPolicies(OptimizingFactory));
// Register Container as IUnityContainer & IUnityContainerAsync
var container = new ExplicitRegistration(typeof(UnityContainer), _containerManager)
{
BuildChain = new[] { new LifetimeStrategy() }
};
// Built-In Features
_registry.Set(typeof(IUnityContainer), null, container);
_registry.Set(typeof(IUnityContainerAsync), null, container);
// Func<> Factory
var funcBuiltInFctory = new ImplicitRegistration();
funcBuiltInFctory.Set(typeof(LifetimeManager), new PerResolveLifetimeManager());
funcBuiltInFctory.Set(typeof(ResolveDelegateFactory), FuncResolver.Factory);
_registry.Set(typeof(Func <>), funcBuiltInFctory);
// Lazy<>
_registry.Set(typeof(Lazy <>), new ImplicitRegistration(typeof(ResolveDelegateFactory), LazyResolver.Factory));
// Enumerable
_registry.Set(typeof(IEnumerable <>), new ImplicitRegistration(typeof(ResolveDelegateFactory), EnumerableResolver.Factory));
}
internal static void SetDiagnosticPolicies(UnityContainer container)
{
// Default policies
container.ContextExecutePlan = UnityContainer.ContextValidatingExecutePlan;
container.ContextResolvePlan = UnityContainer.ContextValidatingResolvePlan;
container.ExecutePlan = container.ExecuteValidatingPlan;
// Processors
var fieldsProcessor = new FieldDiagnostic(container.Defaults);
var methodsProcessor = new MethodDiagnostic(container.Defaults, container);
var propertiesProcessor = new PropertyDiagnostic(container.Defaults);
var constructorProcessor = new ConstructorDiagnostic(container.Defaults, container);
// Processors chain
container._processors = new StagedStrategyChain <MemberProcessor, BuilderStage>
{
{ constructorProcessor, BuilderStage.Creation },
{ fieldsProcessor, BuilderStage.Fields },
{ propertiesProcessor, BuilderStage.Properties },
{ methodsProcessor, BuilderStage.Methods }
};
// Caches
container._processors.Invalidated += (s, e) => container._processorsChain = container._processors.ToArray();
container._processorsChain = container._processors.ToArray();
container.Defaults.ResolveDelegateFactory = container._buildStrategy;
container.Defaults.FieldsSelector = fieldsProcessor;
container.Defaults.MethodsSelector = methodsProcessor;
container.Defaults.PropertiesSelector = propertiesProcessor;
container.Defaults.CtorSelector = constructorProcessor;
var validators = new ImplicitRegistration();
validators.Set(typeof(Func <Type, InjectionMember, ConstructorInfo>), Validating.ConstructorSelector);
validators.Set(typeof(Func <Type, InjectionMember, MethodInfo>), Validating.MethodSelector);
validators.Set(typeof(Func <Type, InjectionMember, FieldInfo>), Validating.FieldSelector);
validators.Set(typeof(Func <Type, InjectionMember, PropertyInfo>), Validating.PropertySelector);
container._validators = validators;
// Registration Validator
container.TypeValidator = (typeFrom, typeTo) =>
{
#if NETSTANDARD1_0 || NETCOREAPP1_0
if (typeFrom != null && !typeFrom.GetTypeInfo().IsGenericType&& !typeTo.GetTypeInfo().IsGenericType&&
!typeFrom.GetTypeInfo().IsAssignableFrom(typeTo.GetTypeInfo()))
#else
if (typeFrom != null && !typeFrom.IsGenericType && !typeTo.IsGenericType &&
!typeFrom.IsAssignableFrom(typeTo))
#endif
{
throw new ArgumentException($"The type {typeTo} cannot be assigned to variables of type {typeFrom}.");
}
};
}
