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);
}
