private void CreateMethodExpressions(
IContainerContext containerContext,
MethodInformation[] injectionMethods,
RegistrationContextData registrationContext,
ResolutionContext resolutionContext,
Expression newExpression,
Expression[] buffer)
{
var length = injectionMethods.Length;
for (var i = 0; i < length; i++)
{
var info = injectionMethods[i];
var paramLength = info.Parameters.Length;
if (paramLength == 0)
{
buffer[i] = newExpression.CallMethod(info.Method);
}
else
{
var parameters = new Expression[paramLength];
for (var j = 0; j < paramLength; j++)
{
parameters[j] = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext,
info.Parameters[j], registrationContext.InjectionParameters);
}
buffer[i] = newExpression.CallMethod(info.Method, parameters);
}
}
}
private IList <MemberBinding> GetMemberBindings(
IContainerContext containerContext,
MemberInformation[] injectionMembers,
RegistrationContextData registrationContext,
ResolutionContext resolutionContext)
{
var length = injectionMembers.Length;
var members = new List <MemberBinding>();
for (var i = 0; i < length; i++)
{
var info = injectionMembers[i];
if (!info.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration,
registrationContext))
{
continue;
}
var expression = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext,
info.TypeInformation, registrationContext.InjectionParameters);
if (expression == null)
{
continue;
}
members.Add(info.MemberInfo.AssignTo(expression));
}
return(members);
}
private IEnumerable <Expression> FillMembersExpression(
IContainerContext containerContext,
MemberInformation[] injectionMembers,
RegistrationContextData registrationContext,
ResolutionContext resolutionContext,
Expression instance)
{
var length = injectionMembers.Length;
var expressions = new List <Expression>();
for (var i = 0; i < length; i++)
{
var member = injectionMembers[i];
if (!member.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration,
registrationContext))
{
continue;
}
var expression = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext,
member.TypeInformation, registrationContext.InjectionParameters);
if (expression == null)
{
continue;
}
expressions.Add(instance.Member(member.MemberInfo).AssignTo(expression));
}
return(expressions);
}
internal MetaInformation(Type typeTo, RegistrationContextData registrationContextData)
{
this.type = typeTo;
var typeInfo = this.type.GetTypeInfo();
this.GenericTypeConstraints = new Dictionary <int, Type[]>();
this.AddConstructors(typeInfo.DeclaredConstructors);
this.AddMethods(typeInfo.DeclaredMethods);
this.InjectionMembers = this.FillMembers(typeInfo).CastToArray();
this.CollectGenericConstraints(typeInfo);
this.SetMemberInjections(registrationContextData);
}
private void SetMemberInjections(RegistrationContextData registrationContextData)
{
foreach (var member in registrationContextData.InjectionMemberNames)
{
var knownMember = this.InjectionMembers.FirstOrDefault(m => m.MemberInfo.Name == member.Key);
if (knownMember == null)
{
continue;
}
knownMember.TypeInformation.ForcedDependency = true;
knownMember.TypeInformation.DependencyName = member.Value;
}
}
private IStashboxContainer RegisterFuncInternal(Delegate factory, Type factoryType, string name)
{
var data = RegistrationContextData.New();
data.Name = name;
data.FuncDelegate = factory;
var registration = new ServiceRegistration(factoryType, this.ContainerContext.ContainerConfigurator,
this.objectBuilderSelector, data, false, false);
this.registrationRepository.AddOrUpdateRegistration(registration, factoryType, false, false);
this.containerExtensionManager.ExecuteOnRegistrationExtensions(this.ContainerContext, registration);
return(this);
}
private void WireUpInternal(object instance, object keyName, Type typeFrom, Type typeTo, bool withoutDisposalTracking, object finalizerDelelgate = null)
{
var data = RegistrationContextData.New();
data.Name = keyName;
data.ExistingInstance = instance;
data.Finalizer = finalizerDelelgate;
var registration = new ServiceRegistration(typeFrom, typeTo,
this.ContainerContext, this.objectBuilderSelector.Get(ObjectBuilder.WireUp),
data, false, !withoutDisposalTracking);
this.registrationRepository.AddOrUpdateRegistration(registration, keyName ?? typeTo, false, false);
this.containerExtensionManager.ExecuteOnRegistrationExtensions(this.ContainerContext, registration);
}
private IDependencyRegistrator RegisterFuncInternal(Delegate factory, Type factoryType, string name)
{
var internalFactoryType = factory.GetType();
var data = RegistrationContextData.New();
data.Name = name;
data.FuncDelegate = factory;
var registration = new ServiceRegistration(factoryType, internalFactoryType,
this.ContainerContext, this.objectBuilderSelector.Get(ObjectBuilder.Func),
data, false, false);
this.registrationRepository.AddOrUpdateRegistration(registration, name ?? (object)internalFactoryType, false, false);
this.containerExtensionManager.ExecuteOnRegistrationExtensions(this.ContainerContext, registration);
return(this);
}
public MemberInformation[] SelectInjectionMembers(RegistrationContextData contextData, ContainerConfiguration containerConfiguration)
{
if (contextData.InjectionMemberNames.Count == 0 &&
containerConfiguration.MemberInjectionFilter == null &&
contextData.MemberInjectionFilter == null)
{
return(this.injectionMembers);
}
var infos = containerConfiguration.MemberInjectionFilter != null
? this.injectionMembers.Where(member =>
containerConfiguration.MemberInjectionFilter(member.TypeInformation))
: this.injectionMembers;
infos = contextData.MemberInjectionFilter != null
? infos.Where(member =>
contextData.MemberInjectionFilter(member.TypeInformation))
: infos;
var infosArray = infos.CastToArray();
var length = infosArray.Length;
var members = new MemberInformation[length];
for (var i = 0; i < length; i++)
{
var member = infosArray[i];
if (contextData.InjectionMemberNames.TryGetValue(member.MemberInfo.Name,
out var dependencyName))
{
var copy = member.Clone();
copy.TypeInformation.ForcedDependency = true;
copy.TypeInformation.DependencyName = dependencyName;
members[i] = copy;
}
else
{
members[i] = member;
}
}
return(members);
}
/// <summary>
/// Determines that the member is injectable in the current context.
/// </summary>
/// <param name="configuration">The container configuration to determine that the container allows the auto injection or not.</param>
/// <param name="contextData">The registration context to determine that the registration allows the auto injection or not.</param>
/// <returns>True if the member is injectable, otherwise false.</returns>
public bool CanInject(ContainerConfiguration configuration, RegistrationContextData contextData)
{
var autoMemberInjectionEnabled = configuration.MemberInjectionWithoutAnnotationEnabled || contextData.AutoMemberInjectionEnabled;
var autoMemberInjectionRule = contextData.AutoMemberInjectionEnabled ? contextData.AutoMemberInjectionRule :
configuration.MemberInjectionWithoutAnnotationRule;
if (autoMemberInjectionEnabled)
{
return(this.TypeInformation.ForcedDependency ||
this.TypeInformation.MemberType == MemberType.Field &&
(autoMemberInjectionRule & Rules.AutoMemberInjectionRules.PrivateFields) == Rules.AutoMemberInjectionRules.PrivateFields ||
this.TypeInformation.MemberType == MemberType.Property &&
((autoMemberInjectionRule & Rules.AutoMemberInjectionRules.PropertiesWithPublicSetter) == Rules.AutoMemberInjectionRules.PropertiesWithPublicSetter &&
((PropertyInfo)this.MemberInfo).HasSetMethod() ||
(autoMemberInjectionRule & Rules.AutoMemberInjectionRules.PropertiesWithLimitedAccess) == Rules.AutoMemberInjectionRules.PropertiesWithLimitedAccess));
}
return(this.TypeInformation.ForcedDependency);
}
public ConstructorInformation FindSelectedConstructor(RegistrationContextData registrationContextData)
{
if (registrationContextData.SelectedConstructor == null)
{
return(null);
}
var length = this.constructors.Length;
for (var i = 0; i < length; i++)
{
var current = this.constructors[i];
if (current.Constructor == registrationContextData.SelectedConstructor)
{
return(current);
}
}
return(null);
}
