protected override void Load(ContainerBuilder builder)
{
NameValueCollection appSettings = ConfigurationManager.AppSettings;
string[] allKeys = appSettings.AllKeys;
string[] array = allKeys;
for (int i = 0; i < array.Length; i++)
{
string text = array[i];
if (text.Count((char c) => c == '.') == 1)
{
string[] array2 = text.Split(new char[]
{
'.'
});
string moduleName = array2[0];
string name = array2[1];
string value = appSettings[text];
Module module = this._modules.FirstOrDefault((Module m) => m.GetType().Name == moduleName + "Module");
if (module != null)
{
PropertyInfo property = module.GetType().GetProperty(name);
object value2 = TypeManipulation.ChangeToCompatibleType(value, property.PropertyType, property);
property.SetValue(module, value2, null);
}
}
}
foreach (Module current in this._modules)
{
ModuleRegistrationExtensions.RegisterModule(builder, current);
}
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">The builder through which components can be registered.</param>
/// <remarks>
/// Note that the ContainerBuilder parameter is unique to this module.
/// </remarks>
protected override void Load(ContainerBuilder builder)
{
var settings = ConfigurationManager.AppSettings;
var keys = settings.AllKeys;
foreach (var setting in keys)
{
if (setting.Count(c => c == '.') != 1)
{
continue;
}
var parts = setting.Split('.');
var moduleName = parts[0];
var propertyName = parts[1];
var value = settings[setting];
var module = _modules.FirstOrDefault(m => m.GetType().Name == moduleName + "Module");
if (module == null)
{
continue;
}
var property = module.GetType().GetProperty(propertyName);
var convertedValue = TypeManipulation.ChangeToCompatibleType(value, property.PropertyType, property);
property.SetValue(module, convertedValue, null);
}
foreach (var module in _modules)
{
builder.RegisterModule(module);
}
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
var instantiatableType = GetInstantiableType(destinationType);
if (value is DictionaryElementCollection &&
instantiatableType != null)
{
var dictionary = (IDictionary)Activator.CreateInstance(instantiatableType);
Type[] generics = instantiatableType.GetGenericArguments();
foreach (var item in (DictionaryElementCollection)value)
{
if (String.IsNullOrEmpty(item.Key))
{
throw new ConfigurationErrorsException("Key cannot be null in a dictionary element.");
}
var convertedKey = TypeManipulation.ChangeToCompatibleType(item.Key, generics[0]);
var convertedValue = TypeManipulation.ChangeToCompatibleType(item.Value, generics[1]);
dictionary.Add(convertedKey, convertedValue);
}
return(dictionary);
}
return(base.ConvertTo(context, culture, value, destinationType));
}
/// <summary>
/// Convert to the Autofac parameter type.
/// </summary>
/// <returns>The parameters represented by this collection.</returns>
public IEnumerable <Parameter> ToParameters()
{
foreach (var parameter in this)
{
var localParameter = parameter;
yield return(new ResolvedParameter(
(pi, c) => pi.Name == localParameter.Name,
(pi, c) => TypeManipulation.ChangeToCompatibleType(localParameter.CoerceValue(), pi.ParameterType)));
}
}
/// <summary>
/// Convert to the Autofac parameter type.
/// </summary>
/// <returns>The parameters represented by this collection.</returns>
public IEnumerable <Parameter> ToParameters()
{
foreach (var parameter in this)
{
var localParameter = parameter;
yield return(new ResolvedParameter(
(pi, c) =>
{
PropertyInfo prop;
return pi.TryGetDeclaringProperty(out prop) &&
prop.Name == localParameter.Name;
},
(pi, c) => TypeManipulation.ChangeToCompatibleType(localParameter.CoerceValue(), pi.ParameterType)));
}
}
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
var instantiatableType = GetInstantiableType(destinationType);
if (value is ListElementCollection &&
instantiatableType != null)
{
Type[] generics = instantiatableType.GetGenericArguments();
var collection = (IList)Activator.CreateInstance(instantiatableType);
foreach (var item in (ListElementCollection)value)
{
collection.Add(TypeManipulation.ChangeToCompatibleType(item.Value, generics[0]));
}
return(collection);
}
return(base.ConvertTo(context, culture, value, destinationType));
}
protected virtual void RegisterConfiguredComponents(ContainerBuilder builder, SectionHandler configurationSection)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (configurationSection == null)
{
throw new ArgumentNullException("configurationSection");
}
foreach (ComponentElement current in configurationSection.Components)
{
IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle> registrationBuilder = RegistrationExtensions.RegisterType(builder, this.LoadType(current.Type, configurationSection.DefaultAssembly));
IEnumerable <Service> enumerable = this.EnumerateComponentServices(current, configurationSection.DefaultAssembly);
foreach (Service current2 in enumerable)
{
registrationBuilder.As(new Service[]
{
current2
});
}
foreach (Parameter current3 in current.Parameters.ToParameters())
{
RegistrationExtensions.WithParameter <object, ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current3);
}
foreach (Parameter current4 in current.Properties.ToParameters())
{
RegistrationExtensions.WithProperty <object, ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current4);
}
foreach (MetadataElement current5 in current.Metadata)
{
registrationBuilder.WithMetadata(current5.Name, TypeManipulation.ChangeToCompatibleType(current5.Value, Type.GetType(current5.Type), null));
}
if (!string.IsNullOrEmpty(current.MemberOf))
{
MemberOf <object, ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current.MemberOf);
}
this.SetLifetimeScope <ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current.InstanceScope);
this.SetComponentOwnership <ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current.Ownership);
this.SetInjectProperties <ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current.InjectProperties);
this.SetAutoActivate <ConcreteReflectionActivatorData, SingleRegistrationStyle>(registrationBuilder, current.AutoActivate);
}
}
/// <summary>
/// Registers individual configured components into a container builder.
/// </summary>
/// <param name="builder">
/// The <see cref="Autofac.ContainerBuilder"/> that should receive the configured registrations.
/// </param>
/// <param name="configurationSection">
/// The <see cref="Autofac.Configuration.SectionHandler"/> containing the configured registrations.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="builder"/> or <paramref name="configurationSection"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="System.Configuration.ConfigurationErrorsException">
/// Thrown if there is any issue in parsing the component configuration into registrations.
/// </exception>
/// <remarks>
/// <para>
/// This is where the individually configured component registrations get added to the <paramref name="builder" />.
/// The <see cref="Autofac.Configuration.SectionHandler.Components"/> collection from the <paramref name="configurationSection" />
/// get processed into individual registrations with associated lifetime scope, name, etc.
/// </para>
/// <para>
/// You may influence the process by overriding this whole method or by overriding these individual
/// parsing subroutines:
/// </para>
/// <list type="bullet">
/// <item>
/// <term><see cref="Autofac.Configuration.ConfigurationRegistrar.SetLifetimeScope"/></term>
/// </item>
/// <item>
/// <term><see cref="Autofac.Configuration.ConfigurationRegistrar.SetComponentOwnership"/></term>
/// </item>
/// <item>
/// <term><see cref="Autofac.Configuration.ConfigurationRegistrar.SetInjectProperties"/></term>
/// </item>
/// </list>
/// </remarks>
protected virtual void RegisterConfiguredComponents(ContainerBuilder builder, SectionHandler configurationSection)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
if (configurationSection == null)
{
throw new ArgumentNullException("configurationSection");
}
foreach (ComponentElement component in configurationSection.Components)
{
var registrar = builder.RegisterType(LoadType(component.Type, configurationSection.DefaultAssembly));
var services = this.EnumerateComponentServices(component, configurationSection.DefaultAssembly);
foreach (var service in services)
{
registrar.As(service);
}
foreach (var param in component.Parameters.ToParameters())
{
registrar.WithParameter(param);
}
foreach (var prop in component.Properties.ToParameters())
{
registrar.WithProperty(prop);
}
foreach (var ep in component.Metadata)
{
registrar.WithMetadata(ep.Name, TypeManipulation.ChangeToCompatibleType(ep.Value, Type.GetType(ep.Type), null));
}
if (!string.IsNullOrEmpty(component.MemberOf))
{
registrar.MemberOf(component.MemberOf);
}
this.SetLifetimeScope(registrar, component.InstanceScope);
this.SetComponentOwnership(registrar, component.Ownership);
this.SetInjectProperties(registrar, component.InjectProperties);
this.SetAutoActivate(registrar, component.AutoActivate);
}
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">The builder.</param>
protected override void Load(ContainerBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException("builder");
}
Assembly defaultAssembly = null;
if (!string.IsNullOrEmpty(_sectionHandler.DefaultAssembly))
{
defaultAssembly = Assembly.Load(_sectionHandler.DefaultAssembly);
}
foreach (ModuleElement moduleElement in _sectionHandler.Modules)
{
var moduleType = LoadType(moduleElement.Type, defaultAssembly);
var moduleActivator = new ReflectionActivator(
moduleType,
new BindingFlagsConstructorFinder(BindingFlags.Public),
new MostParametersConstructorSelector(),
moduleElement.Parameters.ToParameters(),
moduleElement.Properties.ToParameters());
var module = (IModule)moduleActivator.ActivateInstance(Container.Empty, Enumerable.Empty <Parameter>());
builder.RegisterModule(module);
}
foreach (ComponentElement component in _sectionHandler.Components)
{
var registrar = builder.RegisterType(LoadType(component.Type, defaultAssembly));
IList <Service> services = new List <Service>();
if (!string.IsNullOrEmpty(component.Service))
{
var serviceType = LoadType(component.Service, defaultAssembly);
if (!string.IsNullOrEmpty(component.Name))
{
services.Add(new KeyedService(component.Name, serviceType));
}
else
{
services.Add(new TypedService(serviceType));
}
}
else
{
if (!string.IsNullOrEmpty(component.Name))
{
throw new ConfigurationErrorsException(string.Format(
ConfigurationSettingsReaderResources.ServiceTypeMustBeSpecified, component.Name));
}
}
foreach (ServiceElement service in component.Services)
{
var serviceType = LoadType(service.Type, defaultAssembly);
if (!string.IsNullOrEmpty(service.Name))
{
services.Add(new KeyedService(service.Name, serviceType));
}
else
{
services.Add(new TypedService(serviceType));
}
}
foreach (var service in services)
{
registrar.As(service);
}
foreach (var param in component.Parameters.ToParameters())
{
registrar.WithParameter(param);
}
foreach (var prop in component.Properties.ToParameters())
{
registrar.WithProperty(prop);
}
foreach (var ep in component.Metadata)
{
registrar.WithMetadata(
ep.Name, TypeManipulation.ChangeToCompatibleType(ep.Value, Type.GetType(ep.Type)));
}
if (!string.IsNullOrEmpty(component.MemberOf))
{
registrar.MemberOf(component.MemberOf);
}
SetScope(component, registrar);
SetOwnership(component, registrar);
SetInjectProperties(component, registrar);
}
foreach (FileElement file in _sectionHandler.Files)
{
var section = DefaultSectionName;
if (!string.IsNullOrEmpty(file.Section))
{
section = file.Section;
}
var reader = new ConfigurationSettingsReader(section, file.Name);
builder.RegisterModule(reader);
}
}
