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