/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
//we cache presentation models between requests
builder
.RegisterGeneric(typeof(EfRepository <>))
.As(typeof(IRepository <>))
.InstancePerLifetimeScope();
var lconfig = (ReposConfig)config;
if (!Container.IsRegistered <IDbContext>())
{
builder
.Register <IDbContext>(c => new ReposContext(lconfig.ContextName))
.InstancePerLifetimeScope();
}
builder
.RegisterType <PerRequestCacheManager>()
.As <ICacheManager>()
.Named <ICacheManager>("repos_cache_per_request")
.InstancePerLifetimeScope();
}
/// <summary>
/// Gets the handler for a config section
/// </summary>
/// <param name="sectionName">Name of the handler</param>
/// <param name="parentHandler">Handler of the parent section</param>
/// <param name="xmlDoc">XML document containing the config</param>
/// <returns>Handler for a config section</returns>
private static object GetAppSettingsFileHandler(string sectionName, IConfigurationSectionHandler parentHandler, XmlDocument xmlDoc)
{
object handler = null;
XmlNode node = xmlDoc.SelectSingleNode("//" + sectionName);
XmlAttribute att = (XmlAttribute)node.Attributes.RemoveNamedItem("file");
if (att == null || att.Value == null || att.Value.Length == 0)
{
return(parentHandler.Create(null, null, node));
}
else
{
string fileName = att.Value;
string dir = Path.GetDirectoryName(fileName);
string fullName = Path.Combine(dir, fileName);
XmlDocument xmlDoc2 = new XmlDocument();
xmlDoc2.Load(fullName);
object parent = parentHandler.Create(null, null, node);
IConfigurationSectionHandler h = new NameValueSectionHandler();
handler = h.Create(parent, null, xmlDoc2.DocumentElement);
}
return(handler);
}
/// <summary>
/// Gets the handler for a config section
/// </summary>
/// <param name="sectionName">Name of the section</param>
/// <param name="xmlDoc">XML document containing the config</param>
/// <returns>Handler for a config section</returns>
private static IConfigurationSectionHandler GetHandler(string sectionName, XmlDocument xmlDoc)
{
IConfigurationSectionHandler handler = null;
handler = new NameValueSectionHandler();
return(handler);
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(
#if DI_UNITY
#else
ContainerBuilder builder
, IContainer Container
#endif
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
// var appConfig = ConfigurationManager.OpenExeConfiguration("C:\\VSProjects\\Repos\\bin\\ReposServiceConfigures.dll");
// var local = appConfig.Sections.Cast<ConfigurationSection>().Where(s => s.SectionInformation.Name == "ServiceConfig");
var appConfig = ConfigurationManager.OpenExeConfiguration(this.GetType().Assembly.Location);
//Assembly.GetExecutingAssembly().Location);
var localconfig = appConfig.GetSection("ServiceConfig") as IConfigurationSectionHandler;
//if (options.Contains( enumConfigOpts.RegAll))
// SetResolveNameFlag(ResolveDepName.YES);
}
internal IConfigurationSectionHandler GetSectionHandler(string configKey)
{
if ((this.sectionHandlers == null) || !(this.sectionHandlers.Contains(configKey)))
{
if (!this.shouldInheritSections && this.parent != null)
{
return(this.parent.GetSectionHandler(configKey));
}
return(null);
}
object obj = this.sectionHandlers[configKey];
if (obj == removedSectionObj)
{
return(null);
}
IConfigurationSectionHandler sectionHandler = obj as IConfigurationSectionHandler;
if (sectionHandler != null)
{
return(sectionHandler);
}
sectionHandler = CreateSectionHandler(obj);
lock (this.sectionHandlers.SyncRoot)
{
this.sectionHandlers[configKey] = sectionHandler;
}
return(sectionHandler);
}
object GetConfigInternal(string sectionName)
{
object handler = GetHandler(sectionName);
IConfigurationSectionHandler iconf = handler as IConfigurationSectionHandler;
if (iconf == null)
{
return(handler);
}
object parentConfig = null;
if (parent != null)
{
parentConfig = parent.GetConfig(sectionName);
}
XmlDocument doc = GetDocumentForSection(sectionName);
if (doc == null || doc.DocumentElement == null)
{
return(parentConfig);
}
return(iconf.Create(parentConfig, fileName, doc.DocumentElement));
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
if (!Container.IsRegistered<IRule>())
builder
.RegisterType<DefaultDomainRule>()
.As<IRule>()
.InstancePerLifetimeScope();
if (!Container.IsRegistered<IDomainEdit>())
builder
.RegisterType<DefaultServiceEntityEdit>()
.As<IDomainEdit>()
.InstancePerLifetimeScope();
if (!Container.IsRegistered<ICacheService>())
builder
.RegisterType<CacheService>()
.As<ICacheService>()
.InstancePerLifetimeScope();
}
protected virtual void RegisterDependencies(IConfigurationSectionHandler config)
{
var builder = new ContainerBuilder();
var container = builder.Build();
this._containerManager = new ContainerManager(container);
//dependencies
var typeFinder = new WebAppTypeFinder();
builder = new ContainerBuilder();
builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance();
builder.Update(container);
foreach (var dependencyRegistrar
in new Type[] {
typeof(DependencyRegistrar)
, typeof(Repos.DomainModel.Interface.DependencyRegistrar)
, typeof(FilterDependencyRegistrar)
, typeof(ReposDomain.Handlers.DependencyRegistrar)
, typeof(ReposDomain.Filters.DependencyRegistrar)
// ,typeof(ValidationDependencyRegistrar)
// ,typeof(ReposAdmin.ValidationDependencyRegistrar)
})
{
var dep = (IDependencyRegistrar)Activator.CreateInstance(dependencyRegistrar);
builder = new ContainerBuilder();
dep.Register(builder, container, null, config, new TestClassConfigOptions());
builder.Update(container);
}
}
private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
// Get the type of the factory
Type type = TypeUtil.GetType(configRecord.Host, factoryRecord.FactoryTypeName,
true);
// If the type is a ConfigurationSection, that's the type.
if (typeof(ConfigurationSection).IsAssignableFrom(type))
{
_sectionCtor = TypeUtil.GetConstructor(type, typeof(ConfigurationSection),
true);
}
else
{
// Note: in v1, IConfigurationSectionHandler is in effect a factory that has a Create method
// that creates the real section object.
// throws if type does not implement IConfigurationSectionHandler
TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
// Create an instance of the handler
_sectionHandler =
(IConfigurationSectionHandler)TypeUtil.CreateInstance(type);
}
}
/// <summary>
/// Configures the <seealso cref="FrameworkEnvironment"/>
/// </summary>
public static FrameworkEnvironment Configure(IConfigurationSectionHandler configuration = null)
{
if (Instance == null)
{
lock (typeof(FrameworkEnvironment))
{
try
{
//Load configuration from config file if not provided
configuration = configuration ?? (FrameworkConfiguration)ConfigurationManager.GetSection("Framework");
//Create environment and configure it.
var env = new FrameworkEnvironment((IFrameworkConfiguration)configuration);
env.ConfigureContainer();
return(env);
}
catch (Exception exception)
{
Console.WriteLine("Error configuring Environment: {0}", exception);
throw;
}
}
}
return(Instance);
}
public static object ReadSection(Configuration conf, string sectionname)
{
ConfigurationSection section = null;
if (conf == null || (section = conf.GetSection(sectionname)) == null)
{
return(null);
}
string xml = section.SectionInformation.GetRawXml();
Type type = Type.GetType(section.SectionInformation.Type);
if (typeof(IConfigurationSectionHandler).IsAssignableFrom(type))
{
XmlDocument doc = new XmlDocument();
doc.Load(XmlReader.Create(new StringReader(xml)));
IConfigurationSectionHandler configSectionHandlerHandle = Activator.CreateInstance(type) as IConfigurationSectionHandler;
if (configSectionHandlerHandle != null)
{
return(configSectionHandlerHandle.Create(null, null, doc));
}
}
return(xml);
}
private object EvaluateRecursive(IConfigurationSectionHandler sectionHandler, object config, string[] keys, int keyIndex, XmlTextReader reader)
{
string name = keys[keyIndex];
int depth = reader.Depth;
while (reader.Read() && reader.NodeType != XmlNodeType.Element)
{
;
}
while (reader.Depth == depth + 1)
{
if (reader.Name == name)
{
if (keyIndex < keys.Length - 1)
{
config = EvaluateRecursive(sectionHandler, config, keys, keyIndex + 1, reader);
}
else
{
XmlDocument doc = new XmlDocument();
XmlNode section = doc.ReadNode(reader);
config = sectionHandler.Create(config, null, section);
}
continue;
}
SkipToNextElement(reader);
}
return(config);
}
// Get a configuration object, using a particular handler.
// This is for internal use, to provide a fallback handler
// if the section is not mentioned in "machine.default".
internal static Object GetConfig
(String sectionName, IConfigurationSectionHandler handler)
{
// Make sure that the configuration system is initialized.
BuiltinConfigurationSystem system;
lock (typeof(ConfigurationSettings))
{
if (configSystem != null)
{
system = configSystem;
}
else if (configError != null)
{
throw configError;
}
else
{
configSystem = new BuiltinConfigurationSystem();
try
{
configSystem.Init();
}
catch (Exception e)
{
configError = e;
throw;
}
system = configSystem;
}
}
// Look up the specified configuration item.
return(system.GetConfig(sectionName, handler));
}
protected virtual void RegisterDependencies(IConfigurationSectionHandler config)
{
var builder = new ContainerBuilder();
var container = builder.Build();
this._containerManager = new ContainerManager(container);
//dependencies
var typeFinder = new WebAppTypeFinder();
builder = new ContainerBuilder();
builder.RegisterInstance(typeFinder).As <ITypeFinder>().SingleInstance();
builder.Update(container);
//foreach (var dependencyRegistrar
// in new Type[]{
// typeof(DependencyRegistrar)
// ,typeof(Repos.DomainModel.Interface.DependencyRegistrar)
// ,typeof(ReposDomain.Handlers.DependencyRegistrar)
// })
//{
// var dep = (IDependencyRegistrar)Activator.CreateInstance(dependencyRegistrar);
// builder = new ContainerBuilder();
// dep.Register(builder, container, null, config, new DefaultConfOptions());
// builder.Update(container);
//}
ReqisterDependencies.DependencyRegister(container, config, new DefaultConfOptions());
}
private object Evaluate(string configKey)
{
IConfigurationSectionHandler sectionHandler = GetSectionHandler(configKey);
object parentResult = this.parent != null?this.parent.GetConfig(configKey) : null;
string[] keys = configKey.Split(new char[] { '/' });
XmlTextReader reader = null;
object result = null;
try
{
reader = OpenXmlTextReader(this.configurationFile);
result = EvaluateRecursive(sectionHandler, parentResult, keys, 0, reader);
}
catch (XmlException e)
{
throw new ConfigurationException(e.Message, e, this.configurationFile, e.LineNumber);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
RemoveUnresolvedConfig(configKey);
return(result);
}
/// <summary>
/// Reads the specified configuration section from the given <see cref="XmlDocument"/>
/// </summary>
/// <param name="document"></param>
/// <param name="configSectionName"></param>
/// <param name="defaultConfigurationSectionHandlerType"></param>
/// <returns></returns>
public static object GetSectionFromXmlDocument(XmlDocument document, string configSectionName, Type defaultConfigurationSectionHandlerType)
{
Type handlerType = GetSectionHandlerType(document, configSectionName, defaultConfigurationSectionHandlerType);
// obtain Xml node with section content
XmlNode sectionContent = document.SelectSingleNode(string.Format("//{0}/{1}", ConfigurationElement, configSectionName));
if (sectionContent == null)
{
// TODO: review if we shouldn't better simply return null here to match the ConfigurationManager's behaviour?
throw ConfigurationUtils.CreateConfigurationException("Cannot read config section '" + configSectionName + "' - section not found.");
}
// IConfigurationSectionHandler
if (typeof(IConfigurationSectionHandler).IsAssignableFrom(handlerType))
{
IConfigurationSectionHandler handler = (IConfigurationSectionHandler)ObjectUtils.InstantiateType(handlerType);
return(handler.Create(null, null, sectionContent));
}
// NET 2.0 ConfigurationSection
if (typeof(ConfigurationSection).IsAssignableFrom(handlerType))
{
ConfigurationSection section = CreateConfigurationSection(handlerType, new XmlNodeReader(sectionContent));
return(section);
}
// Not supported
throw ConfigurationUtils.CreateConfigurationException("Configuration section '" + configSectionName + "' is neither of type IConfigurationSectionHandler nor ConfigurationSection.");
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
ValidAssmPrefix(config);
if (!Container.IsRegistered <IRule>())
{
builder
.RegisterType <DomainRule>()
.As <IRule>()
.InstancePerLifetimeScope();
}
SetDependency <IEntityRule, IModelRule>(
builder
, Container
, this
.GetType()
.Assembly
.GetTypes()
, EnumServiceTypes.Rules
, options
);
}
object GetConfigInternal(string sectionName, HttpContext context, bool useLoc)
{
object handler = GetHandler(sectionName);
IConfigurationSectionHandler iconf = handler as IConfigurationSectionHandler;
if (iconf == null)
{
return(handler);
}
object parentConfig = null;
if (parent != null)
{
if (useLoc)
{
parentConfig = parent.GetConfig(sectionName, context);
}
else
{
parentConfig = parent.GetConfigOptLocation(sectionName, context, false);
}
}
XmlDocument doc = GetDocumentForSection(sectionName);
if (doc == null || doc.DocumentElement == null)
{
return(parentConfig);
}
return(iconf.Create(parentConfig, fileName, doc.DocumentElement));
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
if (!CallBaseResolver)
{
return;
}
var RegTypes = ResolveTypes <IBaseService>(typeFinder, options);
SetDependency <IBaseService, INullResolver, INullResolver>(
builder
, Container
, RegTypes
, EnumServiceTypes.None //, "Handlers"
, options
);
//var services = this.GetType().Assembly.GetTypes()
// .Where(t => typeof(IBaseService).IsAssignableFrom(t)
// && !t.IsAbstract)
// .Where(i => i.GetInterfaces()
// .Any(g => g.IsGenericType
// && g.GetType().GetInterfaces().Any()))
// .Select(map => new
// {
// target = map
// });
//IHttpContextAccessor
builder
.RegisterType <HttpContextAccessor>()
.As <IHttpContextAccessor>()
.AsImplementedInterfaces()
.InstancePerDependency();
//ICacheService
//foreach (var service in services)
//{
// var serviceName = SetResolveName(service.target);
// if (!Container.IsRegisteredWithName<IBaseService>(serviceName))
// builder
// .RegisterType(service.target)
// .Named<IBaseService>(serviceName)
// .AsImplementedInterfaces()
// .InstancePerDependency();
//}
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
base.Register(builder, Container, typeFinder, config, options);
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
//we cache presentation models between requests
}
//public static IEngine Initialize(IEngine Engine)
//{
// Singleton<IEngine>.Instance = Engine;
// var config = ConfigurationManager.GetSection("ReposConfig") as IConfigurationSectionHandler;
// Singleton<IEngine>.Instance.Initialize(config);
// return Singleton<IEngine>.Instance;
//}
public static IEngine Initialize(IEngine Engine, IConfigurationSectionHandler config)
{
Singleton <IEngine> .Instance = Engine;
// var config = ConfigurationManager.GetSection("ReposConfig") as IConfigurationSectionHandler;
Singleton <IEngine> .Instance.Initialize(config);
return(Singleton <IEngine> .Instance);
}
private object EvaluateRecursive(IConfigurationSectionHandler factory, object config, string [] keys, int iKey, XmlTextReader reader)
{
string name = keys[iKey];
TraceVerbose(" EvaluateRecursive " + iKey + " " + name);
int depth = reader.Depth;
while (reader.Read() && reader.NodeType != XmlNodeType.Element)
{
;
}
while (reader.Depth == depth + 1)
{
TraceVerbose(" EvaluateRecursive " + iKey + " " + name + " Name:" + reader.Name);
if (reader.Name == name)
{
if (iKey < keys.Length - 1)
{
config = EvaluateRecursive(factory, config, keys, iKey + 1, reader);
}
else
{
TraceVerbose(" EvaluateRecursive " + iKey + " calling Create()");
Debug.Assert(iKey == keys.Length - 1);
//
// Call configuration section handler
//
// - try-catch is necessary to insulate config system from exceptions in user config handlers.
// - bubble ConfigurationExceptions & XmlException
// - wrap all others in ConfigurationException
//
int line = reader.LineNumber;
try {
ConfigXmlDocument doc = new ConfigXmlDocument();
doc.LoadSingleElement(_filename, reader);
config = factory.Create(config, null, doc.DocumentElement);
}
catch (ConfigurationException) {
throw;
}
catch (XmlException) {
throw;
}
catch (Exception ex) {
throw new ConfigurationException(
SR.GetString(SR.Exception_in_config_section_handler),
ex, _filename, line);
}
}
continue;
}
StrictSkipToNextElement(reader);
}
return(config);
}
public static T OpenCreate <T>(this IConfigurationSectionHandler <T> configurationLocation)
{
if (!configurationLocation.Exists())
{
return(configurationLocation.Create());
}
return(configurationLocation.Open());
}
/// <summary>
/// Initialize components and plugins in the nop environment.
/// </summary>
/// <param name="config">Config</param>
public void Initialize(IConfigurationSectionHandler configHandler)
{
ConfOptions options = new DefaultConfOptions();
//register dependencies
RegisterDependencies((ReposConfig)configHandler, options);
RunStartupTasks();
}
public object Create(object parent, object configContext, XmlNode section)
{
Type configReaderBaseType = Type.GetType(((XmlElement)section)?.GetAttribute("configReaderBaseType"));
ValidateBaseType(configReaderBaseType);
BaseConfig = CreateDynamicConfigReader(configReaderBaseType);
return(BaseConfig.Create(parent, configContext, section));
}
public void Initialize(IConfigurationSectionHandler config
, TestClassConfigOptions opts = null)
{
if (opts == null)
{
opts = new TestClassConfigOptions();
}
RegisterDependencies(config, opts);
}
public DefaultConfiguration(IConfigurationSectionHandler configurationSectionHandler)
{
MerchantId = configurationSectionHandler.MerchantId;
MerchantSubId = configurationSectionHandler.MerchantSubId;
AcquirerUrl = configurationSectionHandler.AcquirerUrl;
// Retrieve acceptant's certificate
if (!configurationSectionHandler.AcceptantCertificateFilename.IsNullEmptyOrWhiteSpace())
{
// Retrieve certificate from file
if (configurationSectionHandler.AcceptantCertificatePassword.IsNullEmptyOrWhiteSpace())
throw new ConfigurationErrorsException("Password is required when acceptant's certificate is loaded from filesystem");
AcceptantCertificate = GetCertificateFromFile(configurationSectionHandler.AcceptantCertificateFilename, configurationSectionHandler.AcceptantCertificatePassword);
}
else if (configurationSectionHandler.AcceptantCertificateStoreLocation != null)
{
// Retrieve certificate from certificate store
if (configurationSectionHandler.AcceptantCertificateStoreName.IsNullEmptyOrWhiteSpace())
throw new ConfigurationErrorsException("Acceptant's certificate store name is required when loading certificate from the certificate store");
if (configurationSectionHandler.AcceptantCertificateThumbprint.IsNullEmptyOrWhiteSpace())
throw new ConfigurationErrorsException("Acceptant's certificate thumbprint is required when loading certificate from the certificate store");
AcceptantCertificate = GetCertificateFromStore(configurationSectionHandler.AcceptantCertificateStoreLocation.Value, configurationSectionHandler.AcceptantCertificateStoreName, configurationSectionHandler.AcceptantCertificateThumbprint);
}
else
{
// Neither filename nor store location is specified
throw new ConfigurationErrorsException("You should either specify a filename or a certificate store location to specify the acceptant's certificate.");
}
// Retrieve acquirer's certificate
if (!configurationSectionHandler.AcquirerCertificateFilename.IsNullEmptyOrWhiteSpace())
{
// Retrieve certificate from file
AcquirerCertificate = GetCertificateFromFile(configurationSectionHandler.AcquirerCertificateFilename, null);
}
else if (configurationSectionHandler.AcquirerCertificateStoreLocation != null)
{
// Retrieve certificate from certificate store
if (configurationSectionHandler.AcquirerCertificateStoreName.IsNullEmptyOrWhiteSpace())
throw new ConfigurationErrorsException("Acquirer's certificate store name is required when loading certificate from the certificate store");
if (configurationSectionHandler.AcquirerCertificateThumbprint.IsNullEmptyOrWhiteSpace())
throw new ConfigurationErrorsException("Acquirer's certificate thumbprint is required when loading certificate from the certificate store");
AcquirerCertificate = GetCertificateFromStore(configurationSectionHandler.AcquirerCertificateStoreLocation.Value, configurationSectionHandler.AcquirerCertificateStoreName, configurationSectionHandler.AcquirerCertificateThumbprint);
}
else
{
// Neither filename nor store location is specified
throw new ConfigurationErrorsException("You should either specify a filename or a certificate store location to specify the acquirer's certificate.");
}
}
public static object DeserializeXmlNode(
IConfigurationSectionHandler caller,
string sectionName,
XmlNode node,
string typeName,
bool shouldNodeNameMatchTypeName = true)
{
Type typeToDeserialize = Type.GetType(typeName);
if (typeToDeserialize == null)
{
throw NewConfigurationErrorsException(sectionName, $"\"{typeName}\" is not a recognized type name.");
}
string xmlString = node.OuterXml;
string nodeName = node.Name;
string shortTypeName = typeToDeserialize.Name;
if (shouldNodeNameMatchTypeName && nodeName != shortTypeName)
{
xmlString = xmlString
.Replace($"<{nodeName}>", $"<{shortTypeName}>")
.Replace($"<{nodeName} ", $"<{shortTypeName} ")
.Replace($"</{nodeName}>", $"</{shortTypeName}>");
}
var xmlSerializer = new XmlSerializer(typeToDeserialize);
try
{
using (var sr = new StringReader(xmlString))
{
return(xmlSerializer.Deserialize(sr));
}
}
catch (Exception ex)
{
if (ex.Message == "There is an error in the XML document.")
{
Exception inner = ex.InnerException;
if (inner != null && inner.Message.ToLowerInvariant().Contains(sectionName.ToLowerInvariant()))
{
throw new ConfigurationErrorsException(
$"Unable to load from the \"{sectionName} .config section using {caller.GetType().FullName}."
+ " Please check the \"configSections\" definition for this section.",
ex
);
}
}
throw;
}
}
/// <summary>
/// Register services and interfaces
/// </summary>
/// <param name="builder">Container builder</param>
/// <param name="typeFinder">Type finder</param>
/// <param name="config">Config</param>
public override void Register(ContainerBuilder builder
, IContainer Container
, ITypeFinder typeFinder
, IConfigurationSectionHandler config
, IConfigOptions options)
{
base.Register(builder, Container, typeFinder, config, options);
//ValidAssmPrefix(config);
//if (!CallBaseResolver)
// return;
//var RegTypes = ResolveTypes<IHandler>(typeFinder, options);
//if (!Container.IsRegistered<ClientRefInfoHandler>())
// builder
// .RegisterType<ClientRefInfoHandler>()
// .As<IClientRefInfoHandler>()
// .InstancePerLifetimeScope();
//var sup = RegTypes
// .Where(w => !w.GetCustomAttributes(typeof(ServiceNoResolveAttribute), true)
// .Any()).ToList<Type>();
//SetDependency<IEditFilter, INullResolver>(
// builder
// , Container
// , sup
// , EnumServiceTypes.None
// , options
// );
//SetDependency<IHandler, IServiceHandler, INullResolver>(
// builder
// , Container
// , sup
// , EnumServiceTypes.Handlers //, "Handlers"
// , options
// );
//SetDependency<IGenericHandler, INullResolver>(
// builder
// , Container
// , sup
// , EnumServiceTypes.None
// , options
// );
}
private object EvaluateRecursive(IConfigurationSectionHandler factory, object config, string[] keys, int iKey, XmlTextReader reader, object context)
{
string name = keys[iKey];
int depth = reader.Depth;
while (reader.Read() && reader.NodeType != XmlNodeType.Element)
{
;
}
while (reader.Depth == depth + 1)
{
if (reader.Name == name)
{
if (iKey < keys.Length - 1)
{
config = EvaluateRecursive(factory, config, keys, iKey + 1, reader, context);
}
else
{
// Call configuration section handler
int line = reader.LineNumber;
// Try-catch is necessary to protect from exceptions in user config handlers
try
{
ConfigXmlDocument doc = new ConfigXmlDocument();
doc.LoadSingleElement(filename, reader);
config = factory.Create(config, context, doc.DocumentElement);
}
catch (ConfigurationException)
{
// Bubble ConfigurationExceptions
throw;
}
catch (XmlException)
{
// Bubble XmlExceptions
throw;
}
catch (Exception ex)
{
// Wrap all others as ConfigurationExceptions
throw new ConfigurationException("Exception in ConfigSectionHandler", ex, filename, line);
}
}
continue;
}
StrictSkipToNextElement(reader);
}
return(config);
}
private object EvaluateRecursive(IConfigurationSectionHandler factory, object config, string [] keys, int iKey, XmlTextReader reader) {
string name = keys[iKey];
TraceVerbose(" EvaluateRecursive " + iKey + " " + name);
int depth = reader.Depth;
while (reader.Read() && reader.NodeType != XmlNodeType.Element);
while (reader.Depth == depth + 1) {
TraceVerbose(" EvaluateRecursive " + iKey + " " + name + " Name:" + reader.Name);
if (reader.Name == name) {
if (iKey < keys.Length - 1) {
config = EvaluateRecursive(factory, config, keys, iKey + 1, reader);
}
else {
TraceVerbose(" EvaluateRecursive " + iKey + " calling Create()");
Debug.Assert(iKey == keys.Length - 1);
//
// Call configuration section handler
//
// - try-catch is necessary to insulate config system from exceptions in user config handlers.
// - bubble ConfigurationExceptions & XmlException
// - wrap all others in ConfigurationException
//
int line = reader.LineNumber;
try {
ConfigXmlDocument doc = new ConfigXmlDocument();
doc.LoadSingleElement(_filename, reader);
config = factory.Create(config, null, doc.DocumentElement);
}
catch (ConfigurationException) {
throw;
}
catch (XmlException) {
throw;
}
catch (Exception ex) {
throw new ConfigurationException(
SR.GetString(SR.Exception_in_config_section_handler),
ex, _filename, line);
}
}
continue;
}
StrictSkipToNextElement(reader);
}
return config;
}
private object EvaluateRecursive(IConfigurationSectionHandler sectionHandler, object config, string[] keys, int keyIndex, XmlTextReader reader)
{
string name = keys[keyIndex];
int depth = reader.Depth;
while (reader.Read() && reader.NodeType != XmlNodeType.Element)
{
;
}
while (reader.Depth == depth + 1)
{
if (reader.Name == name)
{
if (keyIndex < keys.Length - 1)
{
config = EvaluateRecursive(sectionHandler, config, keys, keyIndex + 1, reader);
}
else
{
XmlDocument doc = new XmlDocument();
XmlNode section = doc.ReadNode(reader);
config = sectionHandler.Create(config, null, section);
}
continue;
}
SkipToNextElement(reader);
}
return config;
}
// Get the object for a specific configuration key and handler.
public Object GetConfig
(String configKey, IConfigurationSectionHandler handler)
{
#if SECOND_PASS
// Bail out if the configuration key is invalid.
if(configKey == null || configKey.Length == 0)
{
return null;
}
// See if we have cached information from last time.
if(cachedInfo.Contains(configKey))
{
return cachedInfo[configKey];
}
// Get the section handler, if necessary.
if(handler == null)
{
Object schema = sectionSchema[configKey];
if(schema == null)
{
// We don't know how to handle the section.
cachedInfo[configKey] = null;
return null;
}
else if(schema == groupMarker)
{
// This section is a group.
cachedInfo[configKey] = null;
return null;
}
else
{
// Create an instance of the specified handler.
Type handlerType = Type.GetType((String)schema);
if(handlerType == null)
{
cachedInfo[configKey] = null;
return null;
}
handler = Activator.CreateInstance(handlerType)
as IConfigurationSectionHandler;
if(handler == null)
{
cachedInfo[configKey] = null;
return null;
}
}
}
// Scan all documents, and collect up the data.
Object data = null;
int posn;
XmlNode section;
for(posn = 0; posn < numDocuments; ++posn)
{
section = FindSectionByName
(documents[posn].DocumentElement, configKey);
if(section != null)
{
data = handler.Create(data, null, section);
}
}
// Cache the data for next time and then return it.
cachedInfo[configKey] = data;
return data;
#else
// Configuration data is not available, so bail out.
return null;
#endif
}
protected static object GetAppSettingsFileHandler(string sectionName, IConfigurationSectionHandler parentHandler, XmlDocument xmlDoc)
{
object handler = null;
XmlNode node = xmlDoc.SelectSingleNode("//" + sectionName);
XmlAttribute att = (XmlAttribute)node.Attributes.RemoveNamedItem("file");
if (att == null || att.Value == null || att.Value.Length == 0)
{
return parentHandler.Create(null, null, node);
}
else
{
string fileName = att.Value;
string dir = Path.GetDirectoryName(fileName);
string fullName = Path.Combine(dir, fileName);
XmlDocument xmlDoc2 = new XmlDocument();
xmlDoc2.Load(fullName);
object parent = parentHandler.Create(null, null, node);
IConfigurationSectionHandler h = new NameValueSectionHandler();
handler = h.Create(parent, null, xmlDoc2.DocumentElement);
}
return handler;
}
// Get a configuration object, using a particular handler.
// This is for internal use, to provide a fallback handler
// if the section is not mentioned in "machine.default".
internal static Object GetConfig
(String sectionName, IConfigurationSectionHandler handler)
{
// Make sure that the configuration system is initialized.
BuiltinConfigurationSystem system;
lock(typeof(ConfigurationSettings))
{
if(configSystem != null)
{
system = configSystem;
}
else if(configError != null)
{
throw configError;
}
else
{
configSystem = new BuiltinConfigurationSystem();
try
{
configSystem.Init();
}
catch(Exception e)
{
configError = e;
throw;
}
system = configSystem;
}
}
// Look up the specified configuration item.
return system.GetConfig(sectionName, handler);
}
private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord)
{
Type c = System.Configuration.TypeUtil.GetTypeWithReflectionPermission(configRecord.Host, factoryRecord.FactoryTypeName, true);
if (typeof(ConfigurationSection).IsAssignableFrom(c))
{
this._sectionCtor = System.Configuration.TypeUtil.GetConstructorWithReflectionPermission(c, typeof(ConfigurationSection), true);
}
else
{
System.Configuration.TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), c, true);
this._sectionHandler = (IConfigurationSectionHandler) System.Configuration.TypeUtil.CreateInstanceWithReflectionPermission(c);
}
}
private void Init(RuntimeConfigurationRecord configRecord, FactoryRecord factoryRecord) {
// Get the type of the factory
Type type = TypeUtil.GetTypeWithReflectionPermission(configRecord.Host, factoryRecord.FactoryTypeName, true);
// If the type is a ConfigurationSection, that's the type.
if (typeof(ConfigurationSection).IsAssignableFrom(type)) {
_sectionCtor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true);
}
else {
// Note: in v1, IConfigurationSectionHandler is in effect a factory that has a Create method
// that creates the real section object.
// throws if type does not implement IConfigurationSectionHandler
TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
// Create an instance of the handler
_sectionHandler = (IConfigurationSectionHandler) TypeUtil.CreateInstanceWithReflectionPermission(type);
}
}
private object EvaluateRecursive(IConfigurationSectionHandler factory, object config, string[] keys, int iKey, XmlTextReader reader)
{
string name = keys[iKey];
int depth = reader.Depth;
while(reader.Read() && reader.NodeType != XmlNodeType.Element);
while (reader.Depth == depth + 1)
{
if (reader.Name == name)
{
if (iKey < keys.Length - 1)
{
config = EvaluateRecursive(factory, config, keys, iKey + 1, reader);
}
else
{
// Call configuration section handler
int line = reader.LineNumber;
// Try-catch is necessary to protect from exceptions in user config handlers
try
{
ConfigXmlDocument doc = new ConfigXmlDocument();
doc.LoadSingleElement(filename, reader);
config = factory.Create(config, null, doc.DocumentElement);
}
catch(ConfigurationException)
{
// Bubble ConfigurationExceptions
throw;
}
catch (XmlException)
{
// Bubble XmlExceptions
throw;
}
catch(Exception ex)
{
// Wrap all others as ConfigurationExceptions
throw new ConfigurationException("Exception in ConfigSectionHandler", ex, filename, line);
}
}
continue;
}
StrictSkipToNextElement(reader);
}
return config;
}
