public object?Resolve(Type type, ImplicitRegistration registration) { if (ReferenceEquals(Registration, registration)) { throw new CircularDependencyException(); } unsafe { var thisContext = this; var context = new BuilderContext { ContainerContext = ContainerContext, Registration = registration, Type = type, List = List, Overrides = Overrides, DeclaringType = Type, #if !NET40 Parent = new IntPtr(Unsafe.AsPointer(ref thisContext)) #endif }; return(context.Pipeline(ref context)); } }
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)); }
public object Resolve(Type type, string name, ImplicitRegistration registration) { unsafe { var thisContext = this; var context = new BuilderContext { Lifetime = Lifetime, Registration = registration, RegistrationType = type, Name = name, Type = registration is ExplicitRegistration containerRegistration ? containerRegistration.Type : type, ExecutePlan = ExecutePlan, ResolvePlan = ResolvePlan, List = List, Overrides = Overrides, DeclaringType = Type, #if !NET40 Parent = new IntPtr(Unsafe.AsPointer(ref thisContext)) #endif }; return(ExecutePlan(registration.BuildChain, ref context)); } }
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}."); } }; }
public PipelineBuilder(Type type, ImplicitRegistration registration, UnityContainer container) { Type = type; Registration = registration; ContainerContext = container.Context; Seed = null; _enumerator = registration.Processors?.GetEnumerator() ?? throw new InvalidOperationException("Processors must be initialized"); }
public override IEnumerable <Expression> Build(UnityContainer container, IEnumerator <Pipeline> enumerator, Type type, ImplicitRegistration registration) { //// Select ConstructorInfo //var selector = GetOrDefault(registration); //var selection = selector.Select(type, registration) // .FirstOrDefault(); //// Select constructor for the Type //object[]? resolvers = null; //ConstructorInfo? info = null; //IEnumerable<Expression> parametersExpr; //switch (selection) //{ // case ConstructorInfo memberInfo: // info = memberInfo; // parametersExpr = CreateParameterExpressions(info.GetParameters()); // break; // case MethodBase<ConstructorInfo> injectionMember: // info = injectionMember.MemberInfo(type); // resolvers = injectionMember.Data; // parametersExpr = CreateParameterExpressions(info.GetParameters(), resolvers); // break; // case Exception exception: // return new[] {Expression.IfThen( // Expression.Equal(Expression.Constant(null), BuilderContextExpression.Existing), // Expression.Throw(Expression.Constant(exception)))}; // default: // return NoConstructorExpr; //} //// Get lifetime manager //var lifetimeManager = (LifetimeManager?)registration.Get(typeof(LifetimeManager)); //return lifetimeManager is PerResolveLifetimeManager // ? new[] { GetResolverExpression(info, resolvers), SetPerBuildSingletonExpr } // : new Expression[] { GetResolverExpression(info, resolvers) }; yield break; }
public override IEnumerable <Expression> Build(UnityContainer container, IEnumerator <Pipeline> enumerator, Type type, ImplicitRegistration registration) { yield break; }
public override bool RequiredToBuildType(IUnityContainer container, Type type, ImplicitRegistration registration, params InjectionMember[] injectionMembers) { if (!(registration is ExplicitRegistration containerRegistration)) { return(null != registration.Map); } // Validate input if (null == containerRegistration.Type || type == containerRegistration.Type) { return(false); } // Set mapping policy #if NETSTANDARD1_0 || NETCOREAPP1_0 if (type.GetTypeInfo().IsGenericTypeDefinition&& containerRegistration.Type.GetTypeInfo().IsGenericTypeDefinition&& null == containerRegistration.Map) #else if (type.IsGenericTypeDefinition && containerRegistration.Type.IsGenericTypeDefinition && null == containerRegistration.Map) #endif { containerRegistration.Map = (Type t) => { #if NETSTANDARD1_0 || NETCOREAPP1_0 || NET40 var targetTypeInfo = t.GetTypeInfo(); #else var targetTypeInfo = t; #endif if (targetTypeInfo.IsGenericTypeDefinition) { // No need to perform a mapping - the source type is an open generic return(containerRegistration.Type); } if (targetTypeInfo.GenericTypeArguments.Length != containerRegistration.Type.GetTypeInfo().GenericTypeParameters.Length) { throw new ArgumentException("Invalid number of generic arguments in types: {registration.MappedToType} and {t}"); } try { return(containerRegistration.Type.MakeGenericType(targetTypeInfo.GenericTypeArguments)); } catch (ArgumentException ae) { throw new MakeGenericTypeFailedException(ae); } }; } return(true); }
/// <summary> /// Create a default <see cref="UnityContainer"/>. /// </summary> public UnityContainer(ModeFlags mode = ModeFlags.Optimized) { if (!mode.IsValid()) { throw new ArgumentException("'Activated' and 'Diagnostic' flags are mutually exclusive."); } ///////////////////////////////////////////////////////////// // Initialize Root _root = this; // Defaults and policies ModeFlags = mode; Defaults = new DefaultPolicies(this); LifetimeContainer = new LifetimeContainer(this); Register = AddOrReplace; // Create Registry and set Factory strategy _metadata = new Registry <int[]>(); _registry = new Registry <IPolicySet>(Defaults); ///////////////////////////////////////////////////////////// //Built-In Registrations // IUnityContainer, IUnityContainerAsync var container = new ImplicitRegistration(this, null) { Pipeline = (ref BuilderContext c) => c.Async ? (object)Task.FromResult <object>(c.Container) : c.Container }; _registry.Set(typeof(IUnityContainer), null, container); _registry.Set(typeof(IUnityContainerAsync), null, container); // Built-In Features var func = new PolicySet(this); _registry.Set(typeof(Func <>), func); func.Set(typeof(LifetimeManager), new PerResolveLifetimeManager()); func.Set(typeof(TypeFactoryDelegate), FuncResolver.Factory); // Func<> Factory _registry.Set(typeof(Lazy <>), new PolicySet(this, typeof(TypeFactoryDelegate), LazyResolver.Factory)); // Lazy<> _registry.Set(typeof(IEnumerable <>), new PolicySet(this, typeof(TypeFactoryDelegate), EnumerableResolver.Factory)); // Enumerable _registry.Set(typeof(IRegex <>), new PolicySet(this, typeof(TypeFactoryDelegate), RegExResolver.Factory)); // Regular Expression Enumerable ///////////////////////////////////////////////////////////// // Pipelines var factory = new FactoryPipeline(); var lifetime = new LifetimePipeline(); // Mode of operation if (ModeFlags.IsOptimized()) { ///////////////////////////////////////////////////////////// // Setup Optimized mode // Create Context Context = new ContainerContext(this, new StagedStrategyChain <Pipeline, Stage> // Type Build Pipeline { { lifetime, Stage.Lifetime }, { factory, Stage.Factory }, { new MappingPipeline(), Stage.TypeMapping }, { new ConstructorPipeline(this), Stage.Creation }, { new FieldPipeline(this), Stage.Fields }, { new PropertyPipeline(this), Stage.Properties }, { new MethodPipeline(this), Stage.Methods } }, new StagedStrategyChain <Pipeline, Stage> // Factory Resolve Pipeline { { lifetime, Stage.Lifetime }, { factory, Stage.Factory } }, new StagedStrategyChain <Pipeline, Stage> // Instance Resolve Pipeline { { lifetime, Stage.Lifetime }, }); } else { ///////////////////////////////////////////////////////////// // Setup Diagnostic mode var diagnostic = new DiagnosticPipeline(); // Create Context Context = new ContainerContext(this, new StagedStrategyChain <Pipeline, Stage> // Type Build Pipeline { { diagnostic, Stage.Diagnostic }, { lifetime, Stage.Lifetime }, { factory, Stage.Factory }, { new MappingDiagnostic(), Stage.TypeMapping }, { new ConstructorDiagnostic(this), Stage.Creation }, { new FieldDiagnostic(this), Stage.Fields }, { new PropertyDiagnostic(this), Stage.Properties }, { new MethodDiagnostic(this), Stage.Methods } }, new StagedStrategyChain <Pipeline, Stage> // Factory Resolve Pipeline { { diagnostic, Stage.Diagnostic }, { lifetime, Stage.Lifetime }, { factory, Stage.Factory } }, new StagedStrategyChain <Pipeline, Stage> // Instance Resolve Pipeline { { diagnostic, Stage.Diagnostic }, { lifetime, Stage.Lifetime }, }); // Build process DependencyResolvePipeline = ValidatingDependencyResolvePipeline; // Validators ValidateType = DiagnosticValidateType; ValidateTypes = DiagnosticValidateTypes; CreateMessage = CreateDiagnosticMessage; } }
public ImplicitRegistrationDebugProxy(ImplicitRegistration set) : base(set) { _registration = set; }
static Implicits() { #region Oblivion var oblivionBaseMasters = new List <ModKey>() { "Oblivion.esm", "Knights.esp", "DLCShiveringIsles.esp", "DLCBattlehornCastle.esp", "DLCHorseArmor.esp", "DLCOrrery.esp", "DLCFrostcrag.esp", "DLCThievesDen.esp", "DLCMehrunesRazor.esp", "DLCVileLair.esp", "DLCSpellTomes.esp", }; Oblivion = new ImplicitRegistration( GameRelease.Oblivion, BaseMasters: new ImplicitModKeyCollection(oblivionBaseMasters), Listings: new ImplicitModKeyCollection(Array.Empty <ModKey>()), RecordFormKeys: Array.Empty <FormKey>()); #endregion #region Skyrim var skyrimModKey = ModKey.FromNameAndExtension("Skyrim.esm"); var skyrimBaseMasters = new ImplicitModKeyCollection(new ModKey[] { skyrimModKey, "Update.esm", "Dawnguard.esm", "HearthFires.esm", "Dragonborn.esm", }); var enderal = ModKey.FromFileName("Enderal - Forgotten Stories.esm"); SkyrimLE = new ImplicitRegistration( GameRelease.SkyrimLE, BaseMasters: skyrimBaseMasters, Listings: skyrimBaseMasters, RecordFormKeys: new HashSet <FormKey>() { // Actor Value Information skyrimModKey.MakeFormKey(0x3F5), skyrimModKey.MakeFormKey(0x5E0), skyrimModKey.MakeFormKey(0x5E1), skyrimModKey.MakeFormKey(0x5E6), skyrimModKey.MakeFormKey(0x5EA), skyrimModKey.MakeFormKey(0x5EE), skyrimModKey.MakeFormKey(0x5EF), skyrimModKey.MakeFormKey(0x5FC), skyrimModKey.MakeFormKey(0x60B), skyrimModKey.MakeFormKey(0x62F), skyrimModKey.MakeFormKey(0x63C), skyrimModKey.MakeFormKey(0x644), skyrimModKey.MakeFormKey(0x647), skyrimModKey.MakeFormKey(0x648), skyrimModKey.MakeFormKey(0x649), // Body Part Data skyrimModKey.MakeFormKey(0x1C), // Eyes skyrimModKey.MakeFormKey(0x1A), // Globals skyrimModKey.MakeFormKey(0x63), // Image Space Adapter skyrimModKey.MakeFormKey(0x164), skyrimModKey.MakeFormKey(0x166), // Impact Data Set skyrimModKey.MakeFormKey(0x276), // Player Reference skyrimModKey.MakeFormKey(0x14), // Texture Set skyrimModKey.MakeFormKey(0x28), }); EnderalLE = SkyrimLE with { BaseMasters = new ImplicitModKeyCollection(SkyrimLE.Listings.And(enderal)) }; SkyrimSE = SkyrimLE with { GameRelease = GameRelease.SkyrimSE }; EnderalSE = SkyrimSE with { BaseMasters = new ImplicitModKeyCollection(SkyrimSE.Listings.And(enderal)) }; SkyrimVR = SkyrimSE with { GameRelease = GameRelease.SkyrimVR, BaseMasters = new ImplicitModKeyCollection(SkyrimSE.BaseMasters.And("SkyrimVR.esm")), Listings = new ImplicitModKeyCollection(SkyrimSE.Listings.And("SkyrimVR.esm")), }; #endregion #region Fallout4 var falloutBaseMasters = new HashSet <ModKey>() { "Fallout4.esm", "DLCRobot.esm", "DLCworkshop01.esm", "DLCCoast.esm", "DLCworkshop02.esm", "DLCworkshop03.esm", "DLCNukaWorld.esm", }; Fallout4 = new ImplicitRegistration( GameRelease.Fallout4, BaseMasters: new ImplicitModKeyCollection(falloutBaseMasters), Listings: new ImplicitModKeyCollection(falloutBaseMasters), RecordFormKeys: new HashSet <FormKey>() { // ToDo }); #endregion }
public virtual IEnumerable <Expression> Build(UnityContainer container, IEnumerator <Pipeline> enumerator, Type type, ImplicitRegistration registration) => throw new NotImplementedException();
public override bool RequiredToBuildType(IUnityContainer container, Type type, ImplicitRegistration registration, params InjectionMember[] injectionMembers) { var policy = registration.LifetimeManager; if (null != policy) { return(policy is TransientLifetimeManager ? false : true); } // Dynamic registration #if NETSTANDARD1_0 || NETCOREAPP1_0 if (!(registration is ExplicitRegistration) && null != type && type.GetTypeInfo().IsGenericType) { return(true); } #else if (!(registration is ExplicitRegistration) && null != type && type.IsGenericType) { return(true); } #endif return(false); }
public override bool RequiredToResolveInstance(IUnityContainer container, ImplicitRegistration registration) => true;
public override bool RequiredToBuildType(IUnityContainer container, Type type, ImplicitRegistration registration, params InjectionMember[] injectionMembers) { // Require Re-Resolve if no injectors specified registration.BuildRequired = (injectionMembers?.Any(m => m.BuildRequired) ?? false) || registration is ExplicitRegistration cr && cr.LifetimeManager is PerResolveLifetimeManager; return(true); }
/// <summary> /// Analyzes registered type /// </summary> /// <param name="container">Reference to hosting container</param> /// <param name="registration">Reference to registration</param> /// <returns>Returns true if this strategy will participate in building of registered type</returns> public virtual bool RequiredToResolveInstance(IUnityContainer container, ImplicitRegistration registration) { return(false); }
/// <summary> /// Analyze registered type /// </summary> /// <param name="container">Reference to hosting container</param> /// <param name="type"></param> /// <param name="registration">Reference to registration</param> /// <param name="injectionMembers"></param> /// <returns>Returns true if this strategy will participate in building of registered type</returns> public virtual bool RequiredToBuildType(IUnityContainer container, Type type, ImplicitRegistration registration, params InjectionMember[] injectionMembers) { return(true); }