protected void ParseRenderer(XmlElement element) { string attribute = element.GetAttribute("renderingClass"); string typeName = element.GetAttribute("renderedClass"); string[] textArray1 = new string[] { "Rendering class [", attribute, "], Rendered class [", typeName, "]." }; LogLog.Debug(declaringType, string.Concat(textArray1)); IObjectRenderer renderer = (IObjectRenderer)OptionConverter.InstantiateByClassName(attribute, typeof(IObjectRenderer), null); if (renderer == null) { LogLog.Error(declaringType, "Could not instantiate renderer [" + attribute + "]."); } else { try { this.m_hierarchy.RendererMap.Put(SystemInfo.GetTypeFromString(typeName, true, true), renderer); } catch (Exception exception) { LogLog.Error(declaringType, "Could not find class [" + typeName + "].", exception); } } }
public void Init() { CLILogsTest.SurchargeLogs(); Option = new Options.AccountOptions(); Config = new DefaultRunConfiguration(ConfigType.Task, CommandApi.List); Convert = new OptionConverter(new UnitTestJsonDeserializer()); }
/// <summary> /// Parses an object renderer. /// </summary> /// <param name="element">The renderer element.</param> /// <remarks> /// <para> /// Parse an XML element that represents a renderer. /// </para> /// </remarks> protected void ParseRenderer(XmlElement element) { string renderingClassName = element.GetAttribute(RENDERING_TYPE_ATTR); string renderedClassName = element.GetAttribute(RENDERED_TYPE_ATTR); LogLog.Debug(declaringType, "Rendering class [" + renderingClassName + "], Rendered class [" + renderedClassName + "]."); IObjectRenderer renderer = (IObjectRenderer)OptionConverter.InstantiateByClassName(renderingClassName, typeof(IObjectRenderer), null); if (renderer == null) { LogLog.Error(declaringType, "Could not instantiate renderer [" + renderingClassName + "]."); return; } else { try { m_hierarchy.RendererMap.Put(SystemInfo.GetTypeFromString(renderedClassName, true, true), renderer); } catch (Exception e) { LogLog.Error(declaringType, "Could not find class [" + renderedClassName + "].", e); } } }
public void CheckConfigGetVerboseOptionsToQuiet() { Options.IVerboseOptions option = new Options.AccountOptions(); option.Quiet = true; var convertOption = new OptionConverter(new JsonDeserializer()); convertOption.ConfigGetVerboseOptions(option); Assert.AreEqual(CLILogs.Verbose, CLILogs.LogsLevel.NoVerbose); }
/// <summary> /// Converts a string value to a target type. /// </summary> /// <param name="type">The type of object to convert the string to.</param> /// <param name="value">The string value to use as the value of the object.</param> /// <returns> /// An object of type <paramref name="type"/> with value <paramref name="value"/> or /// <c>null</c> when the conversion could not be performed. /// </returns> protected object ConvertStringTo(Type type, string value) { // Hack to allow use of Level in property if (type.IsAssignableFrom(typeof(Level))) { // Property wants a level return(m_hierarchy.LevelMap[value]); } return(OptionConverter.ConvertStringTo(type, value)); }
public void CheckConfigGetLogOptionsSetNoColor() { Options.ILogOptions option = new Options.AccountOptions(); bool noColor = true; option.NoColor = noColor; var convertOption = new OptionConverter(new JsonDeserializer()); convertOption.ConfigGetLogOptions(option); Assert.AreEqual(CLILogs.NoColor, noColor); }
/// <summary> /// Converts a string value to a target type. /// </summary> /// <param name="type">The type of object to convert the string to.</param> /// <param name="value">The string value to use as the value of the object.</param> /// <returns> /// <para> /// An object of type <paramref name="type" /> with value <paramref name="value" /> or /// <c>null</c> when the conversion could not be performed. /// </para> /// </returns> protected object ConvertStringTo(Type type, string value) { if ((object)typeof(Level) == type) { Level level = m_hierarchy.LevelMap[value]; if (level == null) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Unknown Level Specified [" + value + "]"); } return(level); } return(OptionConverter.ConvertStringTo(type, value)); }
/// <summary> /// The current version of the NetStandard build of log4net does not replace environment variables. /// We will use the same functionality to replace the environment variables before we pass the xml /// into the standard XmlConfigurator /// </summary> /// <param name="xDocument"></param> private void ReplaceEnvironmentVariables(XDocument xDocument) { var environmentVariables = new Hashtable(Environment.GetEnvironmentVariables(), StringComparer.OrdinalIgnoreCase); var valueAttributes = xDocument .Descendants() .Select(x => x.Attribute("value")) .Where(x => x != null); foreach (var attribute in valueAttributes) { attribute.Value = OptionConverter.SubstituteVariables(attribute.Value, environmentVariables); } }
/// <summary> /// Parses a logger element. /// </summary> /// <param name="loggerElement">The logger element.</param> /// <remarks> /// <para> /// Parse an XML element that represents a logger. /// </para> /// </remarks> protected void ParseLogger(XmlElement loggerElement) { string attribute = loggerElement.GetAttribute("name"); LogLog.Debug(declaringType, "Retrieving an instance of log4net.Repository.Logger for logger [" + attribute + "]."); Logger logger = m_hierarchy.GetLogger(attribute) as Logger; lock (logger) { bool additivity = OptionConverter.ToBoolean(loggerElement.GetAttribute("additivity"), defaultValue: true); LogLog.Debug(declaringType, "Setting [" + logger.Name + "] additivity to [" + additivity.ToString() + "]."); logger.Additivity = additivity; ParseChildrenOfLoggerElement(loggerElement, logger, isRoot: false); } }
public void CheckReadConfigurationFile() { OptionConverter convert = new OptionConverter(new UnitTestJsonDeserializer()); string fileName = "fileName"; string line = "{}"; UnitTestJsonDeserializer.GetFileGet = fileName; UnitTestJsonDeserializer.GetFileRetrun = line; UnitTestJsonDeserializer.DeserializeGet = line; Console.WriteLine(line); AccountConfiguration readFile = convert.ReadConfigurationFile <AccountConfiguration>(fileName, ConfigType.Account, CommandApi.Info); Assert.AreEqual(readFile.Type, ConfigType.Account); Assert.AreEqual(readFile.Command, CommandApi.Info); }
protected void ParseLogger(XmlElement loggerElement) { string attribute = loggerElement.GetAttribute("name"); LogLog.Debug(declaringType, "Retrieving an instance of log4net.Repository.Logger for logger [" + attribute + "]."); Logger log = this.m_hierarchy.GetLogger(attribute) as Logger; lock (log) { bool flag = OptionConverter.ToBoolean(loggerElement.GetAttribute("additivity"), true); object[] objArray1 = new object[] { "Setting [", log.Name, "] additivity to [", flag, "]." }; LogLog.Debug(declaringType, string.Concat(objArray1)); log.Additivity = flag; this.ParseChildrenOfLoggerElement(loggerElement, log, false); } }
/// <summary> /// Converts a string value to a target type. /// </summary> /// <param name="type">The type of object to convert the string to.</param> /// <param name="value">The string value to use as the value of the object.</param> /// <returns> /// <para> /// An object of type <paramref name="type"/> with value <paramref name="value"/> or /// <c>null</c> when the conversion could not be performed. /// </para> /// </returns> protected object ConvertStringTo(Type type, string value) { // Hack to allow use of Level in property if (typeof(Level) == type) { // Property wants a level Level levelValue = m_hierarchy.LevelMap[value]; if (levelValue == null) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Unknown Level Specified [" + value + "]"); } return(levelValue); } return(OptionConverter.ConvertStringTo(type, value)); }
public void CheckConfigReadFile() { OptionConverter convert = new OptionConverter(new UnitTestJsonDeserializer()); string fileName = "fileName"; int verboseLevel = 5; bool verbose = true; bool quiet = true; string line = "{\"VerboseLevel\" : " + verboseLevel + ", \"Verbose\" : " + verbose.ToString().ToLower() + ", \"Quiet\" : " + quiet.ToString().ToLower() + "}"; UnitTestJsonDeserializer.GetFileGet = fileName; UnitTestJsonDeserializer.GetFileRetrun = line; UnitTestJsonDeserializer.DeserializeGet = line; Console.WriteLine(line); Options.AccountOptions readFile = convert.ConfigReadFile <Options.AccountOptions>(fileName); Assert.AreEqual(readFile.Verbose, verbose); Assert.AreEqual(readFile.Quiet, quiet); }
/// <summary> /// Parses a logger element. /// </summary> /// <param name="loggerElement">The logger element.</param> /// <remarks> /// <para> /// Parse an XML element that represents a logger. /// </para> /// </remarks> protected void ParseLogger(XmlElement loggerElement) { // Create a new GodLesZ.Library.Logging.Logger object from the <logger> element. string loggerName = loggerElement.GetAttribute(NAME_ATTR); LogLog.Debug(declaringType, "Retrieving an instance of GodLesZ.Library.Logging.Repository.Logger for logger [" + loggerName + "]."); Logger log = m_hierarchy.GetLogger(loggerName) as Logger; // Setting up a logger needs to be an atomic operation, in order // to protect potential log operations while logger // configuration is in progress. lock (log) { bool additivity = OptionConverter.ToBoolean(loggerElement.GetAttribute(ADDITIVITY_ATTR), true); LogLog.Debug(declaringType, "Setting [" + log.Name + "] additivity to [" + additivity + "]."); log.Additivity = additivity; ParseChildrenOfLoggerElement(loggerElement, log, false); } }
public void TaskWithTagAndTagIntersectThrowAnExcption() { var commandLineParser = new CommandLine.Parser(); CommandLineParser parserObj = new CommandLineParser(new OptionConverter(new JsonDeserializer()), commandLineParser, new ParserUsage(), new VerbFormater()); string[] argv = new string[] { "task info", "--tags", "t1", "t2", "--exclusive-tags", "t3", "t4" }; ParseException ex = null; var converter = new OptionConverter(null); var usage = new ParserUsage(); var parser = commandLineParser.ParseArguments <Options.InfoTaskOptions>(argv); ex = Assert.Throws <ParseException>(() => parser.MapResult( (Options.InfoTaskOptions o) => converter.ConvertGenericGetterOption(ConfigType.Task, CommandApi.Info, o), err => throw new ParseException(usage.PrintHelp(parser, err, argv)))); Assert.IsNotNull(ex); commandLineParser.Dispose(); }
/// <summary> /// Parses an object renderer. /// </summary> /// <param name="element">The renderer element.</param> /// <remarks> /// <para> /// Parse an XML element that represents a renderer. /// </para> /// </remarks> protected void ParseRenderer(XmlElement element) { string attribute = element.GetAttribute("renderingClass"); string attribute2 = element.GetAttribute("renderedClass"); LogLog.Debug(declaringType, "Rendering class [" + attribute + "], Rendered class [" + attribute2 + "]."); IObjectRenderer objectRenderer = (IObjectRenderer)OptionConverter.InstantiateByClassName(attribute, typeof(IObjectRenderer), null); if (objectRenderer == null) { LogLog.Error(declaringType, "Could not instantiate renderer [" + attribute + "]."); } else { try { m_hierarchy.RendererMap.Put(SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, attribute2, throwOnError: true, ignoreCase: true), objectRenderer); } catch (Exception exception) { LogLog.Error(declaringType, "Could not find class [" + attribute2 + "].", exception); } } }
protected void SetParameter(XmlElement element, object target) { string attribute = element.GetAttribute("name"); if ((element.LocalName != "param") || ((attribute == null) || (attribute.Length == 0))) { attribute = element.LocalName; } Type targetType = target.GetType(); Type objA = null; PropertyInfo property = null; MethodInfo info2 = null; property = targetType.GetProperty(attribute, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase); if ((property != null) && property.CanWrite) { objA = property.PropertyType; } else { property = null; info2 = this.FindMethodInfo(targetType, attribute); if (info2 != null) { objA = info2.GetParameters()[0].ParameterType; } } if (objA == null) { string[] textArray1 = new string[] { "XmlHierarchyConfigurator: Cannot find Property [", attribute, "] to set object on [", target.ToString(), "]" }; LogLog.Error(declaringType, string.Concat(textArray1)); } else { string str2 = null; if (element.GetAttributeNode("value") != null) { str2 = element.GetAttribute("value"); } else if (element.HasChildNodes) { IEnumerator enumerator = element.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { XmlNode current = (XmlNode)enumerator.Current; if ((current.NodeType == XmlNodeType.CDATA) || (current.NodeType == XmlNodeType.Text)) { str2 = (str2 != null) ? (str2 + current.InnerText) : current.InnerText; } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } } if (str2 == null) { object obj3 = null; if (ReferenceEquals(objA, typeof(string)) && !this.HasAttributesOrElements(element)) { obj3 = string.Empty; } else { Type defaultTargetType = null; if (IsTypeConstructible(objA)) { defaultTargetType = objA; } obj3 = this.CreateObjectFromXml(element, defaultTargetType, objA); } if (obj3 == null) { LogLog.Error(declaringType, "Failed to create object to set param: " + attribute); } else if (property != null) { object[] objArray5 = new object[] { "Setting Property [", property.Name, "] to object [", obj3, "]" }; LogLog.Debug(declaringType, string.Concat(objArray5)); try { property.SetValue(target, obj3, BindingFlags.SetProperty, null, null, CultureInfo.InvariantCulture); } catch (TargetInvocationException exception4) { object[] objArray6 = new object[] { "Failed to set parameter [", property.Name, "] on object [", target, "] using value [", obj3, "]" }; LogLog.Error(declaringType, string.Concat(objArray6), exception4.InnerException); } } else if (info2 != null) { object[] objArray7 = new object[] { "Setting Collection Property [", info2.Name, "] to object [", obj3, "]" }; LogLog.Debug(declaringType, string.Concat(objArray7)); try { object[] parameters = new object[] { obj3 }; info2.Invoke(target, BindingFlags.InvokeMethod, null, parameters, CultureInfo.InvariantCulture); } catch (TargetInvocationException exception5) { object[] objArray9 = new object[] { "Failed to set parameter [", info2.Name, "] on object [", target, "] using value [", obj3, "]" }; LogLog.Error(declaringType, string.Concat(objArray9), exception5.InnerException); } } } else { try { IDictionary environmentVariables = Environment.GetEnvironmentVariables(); if (this.HasCaseInsensitiveEnvironment) { environmentVariables = this.CreateCaseInsensitiveWrapper(environmentVariables); } str2 = OptionConverter.SubstituteVariables(str2, environmentVariables); } catch (SecurityException) { LogLog.Debug(declaringType, "Security exception while trying to expand environment variables. Error Ignored. No Expansion."); } Type type3 = null; string typeName = element.GetAttribute("type"); if ((typeName != null) && (typeName.Length > 0)) { try { Type c = SystemInfo.GetTypeFromString(typeName, true, true); string[] textArray2 = new string[] { "Parameter [", attribute, "] specified subtype [", c.FullName, "]" }; LogLog.Debug(declaringType, string.Concat(textArray2)); if (objA.IsAssignableFrom(c)) { objA = c; } else if (OptionConverter.CanConvertTypeTo(c, objA)) { type3 = objA; objA = c; } else { string[] textArray3 = new string[] { "subtype [", c.FullName, "] set on [", attribute, "] is not a subclass of property type [", objA.FullName, "] and there are no acceptable type conversions." }; LogLog.Error(declaringType, string.Concat(textArray3)); } } catch (Exception exception) { string[] textArray4 = new string[] { "Failed to find type [", typeName, "] set on [", attribute, "]" }; LogLog.Error(declaringType, string.Concat(textArray4), exception); } } object sourceInstance = this.ConvertStringTo(objA, str2); if ((sourceInstance != null) && (type3 != null)) { string[] textArray5 = new string[] { "Performing additional conversion of value from [", sourceInstance.GetType().Name, "] to [", type3.Name, "]" }; LogLog.Debug(declaringType, string.Concat(textArray5)); sourceInstance = OptionConverter.ConvertTypeTo(sourceInstance, type3); } if (sourceInstance == null) { object[] objArray4 = new object[] { "Unable to set property [", attribute, "] on object [", target, "] using value [", str2, "] (with acceptable conversion types)" }; LogLog.Warn(declaringType, string.Concat(objArray4)); } else if (property != null) { string[] textArray6 = new string[] { "Setting Property [", property.Name, "] to ", sourceInstance.GetType().Name, " value [", sourceInstance.ToString(), "]" }; LogLog.Debug(declaringType, string.Concat(textArray6)); try { property.SetValue(target, sourceInstance, BindingFlags.SetProperty, null, null, CultureInfo.InvariantCulture); } catch (TargetInvocationException exception2) { object[] objArray1 = new object[] { "Failed to set parameter [", property.Name, "] on object [", target, "] using value [", sourceInstance, "]" }; LogLog.Error(declaringType, string.Concat(objArray1), exception2.InnerException); } } else if (info2 != null) { string[] textArray7 = new string[] { "Setting Collection Property [", info2.Name, "] to ", sourceInstance.GetType().Name, " value [", sourceInstance.ToString(), "]" }; LogLog.Debug(declaringType, string.Concat(textArray7)); try { object[] parameters = new object[] { sourceInstance }; info2.Invoke(target, BindingFlags.InvokeMethod, null, parameters, CultureInfo.InvariantCulture); } catch (TargetInvocationException exception3) { object[] objArray3 = new object[] { "Failed to set parameter [", attribute, "] on object [", target, "] using value [", sourceInstance, "]" }; LogLog.Error(declaringType, string.Concat(objArray3), exception3.InnerException); } } } } }
public void Configure(XmlElement element) { if ((element != null) && (this.m_hierarchy != null)) { if (element.LocalName != "log4net") { LogLog.Error(declaringType, "Xml element is - not a <log4net> element."); } else { if (!LogLog.EmitInternalMessages) { string argValue = element.GetAttribute("emitDebug"); LogLog.Debug(declaringType, "emitDebug attribute [" + argValue + "]."); if ((argValue.Length > 0) && (argValue != "null")) { LogLog.EmitInternalMessages = OptionConverter.ToBoolean(argValue, true); } else { LogLog.Debug(declaringType, "Ignoring emitDebug attribute."); } } if (!LogLog.InternalDebugging) { string argValue = element.GetAttribute("debug"); LogLog.Debug(declaringType, "debug attribute [" + argValue + "]."); if ((argValue.Length > 0) && (argValue != "null")) { LogLog.InternalDebugging = OptionConverter.ToBoolean(argValue, true); } else { LogLog.Debug(declaringType, "Ignoring debug attribute."); } string str4 = element.GetAttribute("configDebug"); if ((str4.Length > 0) && (str4 != "null")) { LogLog.Warn(declaringType, "The \"configDebug\" attribute is deprecated."); LogLog.Warn(declaringType, "Use the \"debug\" attribute instead."); LogLog.InternalDebugging = OptionConverter.ToBoolean(str4, true); } } ConfigUpdateMode merge = ConfigUpdateMode.Merge; string attribute = element.GetAttribute("update"); if ((attribute != null) && (attribute.Length > 0)) { try { merge = (ConfigUpdateMode)OptionConverter.ConvertStringTo(typeof(ConfigUpdateMode), attribute); } catch { LogLog.Error(declaringType, "Invalid update attribute value [" + attribute + "]"); } } LogLog.Debug(declaringType, "Configuration update mode [" + merge.ToString() + "]."); if (merge == ConfigUpdateMode.Overwrite) { this.m_hierarchy.ResetConfiguration(); LogLog.Debug(declaringType, "Configuration reset before reading config."); } IEnumerator enumerator = element.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { XmlNode current = (XmlNode)enumerator.Current; if (current.NodeType == XmlNodeType.Element) { XmlElement loggerElement = (XmlElement)current; if (loggerElement.LocalName == "logger") { this.ParseLogger(loggerElement); continue; } if (loggerElement.LocalName == "category") { this.ParseLogger(loggerElement); continue; } if (loggerElement.LocalName == "root") { this.ParseRoot(loggerElement); continue; } if (loggerElement.LocalName == "renderer") { this.ParseRenderer(loggerElement); continue; } if (loggerElement.LocalName != "appender") { this.SetParameter(loggerElement, this.m_hierarchy); } } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } string str6 = element.GetAttribute("threshold"); LogLog.Debug(declaringType, "Hierarchy Threshold [" + str6 + "]"); if ((str6.Length > 0) && (str6 != "null")) { Level level = (Level)this.ConvertStringTo(typeof(Level), str6); if (level != null) { this.m_hierarchy.Threshold = level; } else { LogLog.Warn(declaringType, "Unable to set hierarchy threshold using value [" + str6 + "] (with acceptable conversion types)"); } } } } }
/// <summary> /// Creates an object as specified in XML. /// </summary> /// <param name="element">The XML element that contains the definition of the object.</param> /// <param name="defaultTargetType">The object type to use if not explicitly specified.</param> /// <param name="typeConstraint">The type that the returned object must be or must inherit from.</param> /// <returns>The object or <c>null</c></returns> /// <remarks> /// <para> /// Parse an XML element and create an object instance based on the configuration /// data. /// </para> /// <para> /// The type of the instance may be specified in the XML. If not /// specified then the <paramref name="defaultTargetType" /> is used /// as the type. However the type is specified it must support the /// <paramref name="typeConstraint" /> type. /// </para> /// </remarks> protected object CreateObjectFromXml(XmlElement element, Type defaultTargetType, Type typeConstraint) { Type type = null; string attribute = element.GetAttribute("type"); if (attribute == null || attribute.Length == 0) { if ((object)defaultTargetType == null) { LogLog.Error(declaringType, "Object type not specified. Cannot create object of type [" + typeConstraint.FullName + "]. Missing Value or Type."); return(null); } type = defaultTargetType; } else { try { type = SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, attribute, throwOnError: true, ignoreCase: true); } catch (Exception exception) { LogLog.Error(declaringType, "Failed to find type [" + attribute + "]", exception); return(null); } } bool flag = false; if ((object)typeConstraint != null && !CompatibilityExtensions.IsAssignableFrom(typeConstraint, type)) { if (!OptionConverter.CanConvertTypeTo(type, typeConstraint)) { LogLog.Error(declaringType, "Object type [" + type.FullName + "] is not assignable to type [" + typeConstraint.FullName + "]. There are no acceptable type conversions."); return(null); } flag = true; } object obj = null; try { obj = Activator.CreateInstance(type); } catch (Exception ex) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Failed to construct object of type [" + type.FullName + "] Exception: " + ex.ToString()); } foreach (XmlNode childNode in element.ChildNodes) { if (childNode.NodeType == XmlNodeType.Element) { SetParameter((XmlElement)childNode, obj); } } (obj as IOptionHandler)?.ActivateOptions(); if (flag) { return(OptionConverter.ConvertTypeTo(obj, typeConstraint)); } return(obj); }
/// <summary> /// Sets a paramater on an object. /// </summary> /// <remarks> /// The parameter name must correspond to a writable property /// on the object. The value of the parameter is a string, /// therefore this function will attempt to set a string /// property first. If unable to set a string property it /// will inspect the property and its argument type. It will /// attempt to call a static method called 'Parse' on the /// type of the property. This method will take a single /// string argument and return a value that can be used to /// set the property. /// </remarks> /// <param name="element">The parameter element.</param> /// <param name="target">The object to set the parameter on.</param> protected void SetParameter(XmlElement element, object target) { // Get the property name string name = element.GetAttribute(NAME_ATTR); // If the name attribute does not exist then use the name of the element if (element.LocalName != PARAM_TAG || name == null || name.Length == 0) { name = element.LocalName; } // Look for the property on the target object Type targetType = target.GetType(); Type propertyType = null; PropertyInfo propInfo = null; MethodInfo methInfo = null; // Try to find a writable property propInfo = targetType.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase); if (propInfo != null && propInfo.CanWrite) { // found a property propertyType = propInfo.PropertyType; } else { propInfo = null; // look for a method with the signature Add<property>(type) methInfo = targetType.GetMethod("Add" + name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase); if (methInfo != null && methInfo.IsPublic && !methInfo.IsStatic) { System.Reflection.ParameterInfo[] methParams = methInfo.GetParameters(); if (methParams.Length == 1) { propertyType = methParams[0].ParameterType; } else { methInfo = null; } } else { methInfo = null; } } if (propertyType == null) { LogLog.Error("DOMConfigurator: Cannot find Property [" + name + "] to set object on [" + target.ToString() + "]"); } else { if (element.GetAttributeNode(VALUE_ATTR) != null) { string propertyValue = element.GetAttribute(VALUE_ATTR); // Fixup embedded non-printable chars propertyValue = OptionConverter.ConvertSpecialChars(propertyValue); #if !NETCF try { // Expand environment variables in the string. propertyValue = OptionConverter.SubstVars(propertyValue, Environment.GetEnvironmentVariables()); } catch (System.Security.SecurityException) { // This security exception will occur if the caller does not have // unrestricted environment permission. If this occurs the expansion // will be skipped with the following warning message. LogLog.Debug("DOMConfigurator: Security exception while trying to expand environment variables. Error Ignored. No Expansion."); } #endif // Now try to convert the string value to an acceptable type // to pass to this property. object convertedValue = ConvertStringTo(propertyType, propertyValue); if (convertedValue != null) { if (propInfo != null) { // Got a converted result LogLog.Debug("DOMConfigurator: Setting Property [" + propInfo.Name + "] to " + convertedValue.GetType().Name + " value [" + convertedValue.ToString() + "]"); // Pass to the property propInfo.SetValue(target, convertedValue, BindingFlags.SetProperty, null, null, CultureInfo.InvariantCulture); } else if (methInfo != null) { // Got a converted result LogLog.Debug("DOMConfigurator: Setting Collection Property [" + methInfo.Name + "] to " + convertedValue.GetType().Name + " value [" + convertedValue.ToString() + "]"); // Pass to the property methInfo.Invoke(target, BindingFlags.InvokeMethod, null, new object[] { convertedValue }, CultureInfo.InvariantCulture); } } else { LogLog.Warn("DOMConfigurator: Unable to set property [" + name + "] on object [" + target + "] using value [" + propertyValue + "] (with acceptable conversion types)"); } } else { // No value specified Type defaultObjectType = null; if (propertyType.IsClass && !propertyType.IsAbstract) { defaultObjectType = propertyType; } object createdObject = CreateObjectFromXml(element, defaultObjectType, propertyType); if (createdObject == null) { LogLog.Error("DOMConfigurator: Failed to create object to set param: " + name); } else { if (propInfo != null) { // Got a converted result LogLog.Debug("DOMConfigurator: Setting Property [" + propInfo.Name + "] to object [" + createdObject + "]"); // Pass to the property propInfo.SetValue(target, createdObject, BindingFlags.SetProperty, null, null, CultureInfo.InvariantCulture); } else if (methInfo != null) { // Got a converted result LogLog.Debug("DOMConfigurator: Setting Collection Property [" + methInfo.Name + "] to object [" + createdObject + "]"); // Pass to the property methInfo.Invoke(target, BindingFlags.InvokeMethod, null, new object[] { createdObject }, CultureInfo.InvariantCulture); } } } } }
/// <summary> /// Sets a parameter on an object. /// </summary> /// <param name="element">The parameter element.</param> /// <param name="target">The object to set the parameter on.</param> /// <remarks> /// The parameter name must correspond to a writable property /// on the object. The value of the parameter is a string, /// therefore this function will attempt to set a string /// property first. If unable to set a string property it /// will inspect the property and its argument type. It will /// attempt to call a static method called <c>Parse</c> on the /// type of the property. This method will take a single /// string argument and return a value that can be used to /// set the property. /// </remarks> protected void SetParameter(XmlElement element, object target) { string text = element.GetAttribute("name"); if (element.LocalName != "param" || text == null || text.Length == 0) { text = element.LocalName; } Type type = target.GetType(); Type type2 = null; PropertyInfo propertyInfo = null; MethodInfo methodInfo = null; propertyInfo = type.GetProperty(text, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if ((object)propertyInfo != null && propertyInfo.CanWrite) { type2 = propertyInfo.PropertyType; } else { propertyInfo = null; methodInfo = FindMethodInfo(type, text); if ((object)methodInfo != null) { type2 = methodInfo.GetParameters()[0].ParameterType; } } if ((object)type2 == null) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Cannot find Property [" + text + "] to set object on [" + target.ToString() + "]"); return; } string text2 = null; if (element.GetAttributeNode("value") != null) { text2 = element.GetAttribute("value"); } else if (element.HasChildNodes) { foreach (XmlNode childNode in element.ChildNodes) { if (childNode.NodeType == XmlNodeType.CDATA || childNode.NodeType == XmlNodeType.Text) { text2 = ((text2 != null) ? (text2 + childNode.InnerText) : childNode.InnerText); } } } if (text2 != null) { Type type3 = null; string attribute = element.GetAttribute("type"); if (attribute != null && attribute.Length > 0) { try { Type typeFromString = SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, attribute, throwOnError: true, ignoreCase: true); LogLog.Debug(declaringType, "Parameter [" + text + "] specified subtype [" + typeFromString.FullName + "]"); if (!CompatibilityExtensions.IsAssignableFrom(type2, typeFromString)) { if (OptionConverter.CanConvertTypeTo(typeFromString, type2)) { type3 = type2; type2 = typeFromString; } else { LogLog.Error(declaringType, "subtype [" + typeFromString.FullName + "] set on [" + text + "] is not a subclass of property type [" + type2.FullName + "] and there are no acceptable type conversions."); } } else { type2 = typeFromString; } } catch (Exception exception) { LogLog.Error(declaringType, "Failed to find type [" + attribute + "] set on [" + text + "]", exception); } } object obj = ConvertStringTo(type2, text2); if (obj != null && (object)type3 != null) { LogLog.Debug(declaringType, "Performing additional conversion of value from [" + obj.GetType().Name + "] to [" + type3.Name + "]"); obj = OptionConverter.ConvertTypeTo(obj, type3); } if (obj != null) { if ((object)propertyInfo != null) { LogLog.Debug(declaringType, "Setting Property [" + propertyInfo.Name + "] to " + obj.GetType().Name + " value [" + obj.ToString() + "]"); try { propertyInfo.SetValue(target, obj, null); } catch (TargetInvocationException ex) { LogLog.Error(declaringType, "Failed to set parameter [" + propertyInfo.Name + "] on object [" + target + "] using value [" + obj + "]", ex.InnerException); } } else if ((object)methodInfo != null) { LogLog.Debug(declaringType, "Setting Collection Property [" + methodInfo.Name + "] to " + obj.GetType().Name + " value [" + obj.ToString() + "]"); try { methodInfo.Invoke(target, new object[1] { obj }); } catch (TargetInvocationException ex2) { LogLog.Error(declaringType, "Failed to set parameter [" + text + "] on object [" + target + "] using value [" + obj + "]", ex2.InnerException); } } } else { LogLog.Warn(declaringType, "Unable to set property [" + text + "] on object [" + target + "] using value [" + text2 + "] (with acceptable conversion types)"); } return; } object obj2 = null; if ((object)type2 == typeof(string) && !HasAttributesOrElements(element)) { obj2 = ""; } else { Type defaultTargetType = null; if (IsTypeConstructible(type2)) { defaultTargetType = type2; } obj2 = CreateObjectFromXml(element, defaultTargetType, type2); } if (obj2 == null) { LogLog.Error(declaringType, "Failed to create object to set param: " + text); } else if ((object)propertyInfo != null) { LogLog.Debug(declaringType, "Setting Property [" + propertyInfo.Name + "] to object [" + obj2 + "]"); try { propertyInfo.SetValue(target, obj2, null); } catch (TargetInvocationException ex3) { LogLog.Error(declaringType, "Failed to set parameter [" + propertyInfo.Name + "] on object [" + target + "] using value [" + obj2 + "]", ex3.InnerException); } } else if ((object)methodInfo != null) { LogLog.Debug(declaringType, "Setting Collection Property [" + methodInfo.Name + "] to object [" + obj2 + "]"); try { methodInfo.Invoke(target, new object[1] { obj2 }); } catch (TargetInvocationException ex4) { LogLog.Error(declaringType, "Failed to set parameter [" + methodInfo.Name + "] on object [" + target + "] using value [" + obj2 + "]", ex4.InnerException); } } }
/// <summary> /// Sets a parameter on an object. /// </summary> /// <param name="element">The parameter element.</param> /// <param name="target">The object to set the parameter on.</param> /// <remarks> /// The parameter name must correspond to a writable property /// on the object. The value of the parameter is a string, /// therefore this function will attempt to set a string /// property first. If unable to set a string property it /// will inspect the property and its argument type. It will /// attempt to call a static method called <c>Parse</c> on the /// type of the property. This method will take a single /// string argument and return a value that can be used to /// set the property. /// </remarks> protected void SetParameter(XmlElement element, object target) { // Get the property name string name = element.GetAttribute(NAME_ATTR); // If the name attribute does not exist then use the name of the element if (element.LocalName != PARAM_TAG || name == null || name.Length == 0) { name = element.LocalName; } // Look for the property on the target object Type targetType = target.GetType(); Type propertyType = null; PropertyInfo propInfo = null; MethodInfo methInfo = null; // Try to find a writable property propInfo = targetType.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase); if (propInfo != null && propInfo.CanWrite) { // found a property propertyType = propInfo.PropertyType; } else { propInfo = null; // look for a method with the signature Add<property>(type) methInfo = FindMethodInfo(targetType, name); if (methInfo != null) { propertyType = methInfo.GetParameters()[0].ParameterType; } } if (propertyType == null) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Cannot find Property [" + name + "] to set object on [" + target.ToString() + "]"); } else { string propertyValue = null; if (element.GetAttributeNode(VALUE_ATTR) != null) { propertyValue = element.GetAttribute(VALUE_ATTR); } else if (element.HasChildNodes) { // Concatenate the CDATA and Text nodes together foreach (XmlNode childNode in element.ChildNodes) { if (childNode.NodeType == XmlNodeType.CDATA || childNode.NodeType == XmlNodeType.Text) { if (propertyValue == null) { propertyValue = childNode.InnerText; } else { propertyValue += childNode.InnerText; } } } } if (propertyValue != null) { #if !NETCF try { // Expand environment variables in the string. propertyValue = OptionConverter.SubstituteVariables(propertyValue, Environment.GetEnvironmentVariables()); } catch (System.Security.SecurityException) { // This security exception will occur if the caller does not have // unrestricted environment permission. If this occurs the expansion // will be skipped with the following warning message. LogLog.Debug(declaringType, "Security exception while trying to expand environment variables. Error Ignored. No Expansion."); } #endif Type parsedObjectConversionTargetType = null; // Check if a specific subtype is specified on the element using the 'type' attribute string subTypeString = element.GetAttribute(TYPE_ATTR); if (subTypeString != null && subTypeString.Length > 0) { // Read the explicit subtype try { Type subType = SystemInfo.GetTypeFromString(subTypeString, true, true); LogLog.Debug(declaringType, "Parameter [" + name + "] specified subtype [" + subType.FullName + "]"); if (!propertyType.IsAssignableFrom(subType)) { // Check if there is an appropriate type converter if (OptionConverter.CanConvertTypeTo(subType, propertyType)) { // Must re-convert to the real property type parsedObjectConversionTargetType = propertyType; // Use sub type as intermediary type propertyType = subType; } else { LogLog.Error(declaringType, "subtype [" + subType.FullName + "] set on [" + name + "] is not a subclass of property type [" + propertyType.FullName + "] and there are no acceptable type conversions."); } } else { // The subtype specified is found and is actually a subtype of the property // type, therefore we can switch to using this type. propertyType = subType; } } catch (Exception ex) { LogLog.Error(declaringType, "Failed to find type [" + subTypeString + "] set on [" + name + "]", ex); } } // Now try to convert the string value to an acceptable type // to pass to this property. object convertedValue = ConvertStringTo(propertyType, propertyValue); // Check if we need to do an additional conversion if (convertedValue != null && parsedObjectConversionTargetType != null) { LogLog.Debug(declaringType, "Performing additional conversion of value from [" + convertedValue.GetType().Name + "] to [" + parsedObjectConversionTargetType.Name + "]"); convertedValue = OptionConverter.ConvertTypeTo(convertedValue, parsedObjectConversionTargetType); } if (convertedValue != null) { if (propInfo != null) { // Got a converted result LogLog.Debug(declaringType, "Setting Property [" + propInfo.Name + "] to " + convertedValue.GetType().Name + " value [" + convertedValue.ToString() + "]"); try { // Pass to the property propInfo.SetValue(target, convertedValue, BindingFlags.SetProperty, null, null, CultureInfo.InvariantCulture); } catch (TargetInvocationException targetInvocationEx) { LogLog.Error(declaringType, "Failed to set parameter [" + propInfo.Name + "] on object [" + target + "] using value [" + convertedValue + "]", targetInvocationEx.InnerException); } } else if (methInfo != null) { // Got a converted result LogLog.Debug(declaringType, "Setting Collection Property [" + methInfo.Name + "] to " + convertedValue.GetType().Name + " value [" + convertedValue.ToString() + "]"); try { // Pass to the property methInfo.Invoke(target, BindingFlags.InvokeMethod, null, new object[] { convertedValue }, CultureInfo.InvariantCulture); } catch (TargetInvocationException targetInvocationEx) { LogLog.Error(declaringType, "Failed to set parameter [" + name + "] on object [" + target + "] using value [" + convertedValue + "]", targetInvocationEx.InnerException); } } } else { LogLog.Warn(declaringType, "Unable to set property [" + name + "] on object [" + target + "] using value [" + propertyValue + "] (with acceptable conversion types)"); } } else { object createdObject = null; if (propertyType == typeof(string) && !HasAttributesOrElements(element)) { // If the property is a string and the element is empty (no attributes // or child elements) then we special case the object value to an empty string. // This is necessary because while the String is a class it does not have // a default constructor that creates an empty string, which is the behavior // we are trying to simulate and would be expected from CreateObjectFromXml createdObject = ""; } else { // No value specified Type defaultObjectType = null; if (IsTypeConstructible(propertyType)) { defaultObjectType = propertyType; } createdObject = CreateObjectFromXml(element, defaultObjectType, propertyType); } if (createdObject == null) { LogLog.Error(declaringType, "Failed to create object to set param: " + name); } else { if (propInfo != null) { // Got a converted result LogLog.Debug(declaringType, "Setting Property [" + propInfo.Name + "] to object [" + createdObject + "]"); try { // Pass to the property propInfo.SetValue(target, createdObject, BindingFlags.SetProperty, null, null, CultureInfo.InvariantCulture); } catch (TargetInvocationException targetInvocationEx) { LogLog.Error(declaringType, "Failed to set parameter [" + propInfo.Name + "] on object [" + target + "] using value [" + createdObject + "]", targetInvocationEx.InnerException); } } else if (methInfo != null) { // Got a converted result LogLog.Debug(declaringType, "Setting Collection Property [" + methInfo.Name + "] to object [" + createdObject + "]"); try { // Pass to the property methInfo.Invoke(target, BindingFlags.InvokeMethod, null, new object[] { createdObject }, CultureInfo.InvariantCulture); } catch (TargetInvocationException targetInvocationEx) { LogLog.Error(declaringType, "Failed to set parameter [" + methInfo.Name + "] on object [" + target + "] using value [" + createdObject + "]", targetInvocationEx.InnerException); } } } } } }
/// <summary> /// Configure the hierarchy by parsing a DOM tree of XML elements. /// </summary> /// <param name="element">The root element to parse.</param> /// <remarks> /// <para> /// Configure the hierarchy by parsing a DOM tree of XML elements. /// </para> /// </remarks> public void Configure(XmlElement element) { if (element == null || m_hierarchy == null) { return; } if (element.LocalName != "log4net") { LogLog.Error(declaringType, "Xml element is - not a <log4net> element."); return; } if (!LogLog.EmitInternalMessages) { string attribute = element.GetAttribute("emitDebug"); LogLog.Debug(declaringType, "emitDebug attribute [" + attribute + "]."); if (attribute.Length > 0 && attribute != "null") { LogLog.EmitInternalMessages = OptionConverter.ToBoolean(attribute, defaultValue: true); } else { LogLog.Debug(declaringType, "Ignoring emitDebug attribute."); } } if (!LogLog.InternalDebugging) { string attribute2 = element.GetAttribute("debug"); LogLog.Debug(declaringType, "debug attribute [" + attribute2 + "]."); if (attribute2.Length > 0 && attribute2 != "null") { LogLog.InternalDebugging = OptionConverter.ToBoolean(attribute2, defaultValue: true); } else { LogLog.Debug(declaringType, "Ignoring debug attribute."); } string attribute3 = element.GetAttribute("configDebug"); if (attribute3.Length > 0 && attribute3 != "null") { LogLog.Warn(declaringType, "The \"configDebug\" attribute is deprecated."); LogLog.Warn(declaringType, "Use the \"debug\" attribute instead."); LogLog.InternalDebugging = OptionConverter.ToBoolean(attribute3, defaultValue: true); } } ConfigUpdateMode configUpdateMode = ConfigUpdateMode.Merge; string attribute4 = element.GetAttribute("update"); if (attribute4 != null && attribute4.Length > 0) { try { configUpdateMode = (ConfigUpdateMode)OptionConverter.ConvertStringTo(typeof(ConfigUpdateMode), attribute4); } catch { LogLog.Error(declaringType, "Invalid update attribute value [" + attribute4 + "]"); } } LogLog.Debug(declaringType, "Configuration update mode [" + configUpdateMode.ToString() + "]."); if (configUpdateMode == ConfigUpdateMode.Overwrite) { m_hierarchy.ResetConfiguration(); LogLog.Debug(declaringType, "Configuration reset before reading config."); } foreach (XmlNode childNode in element.ChildNodes) { if (childNode.NodeType == XmlNodeType.Element) { XmlElement xmlElement = (XmlElement)childNode; if (xmlElement.LocalName == "logger") { ParseLogger(xmlElement); } else if (xmlElement.LocalName == "category") { ParseLogger(xmlElement); } else if (xmlElement.LocalName == "root") { ParseRoot(xmlElement); } else if (xmlElement.LocalName == "renderer") { ParseRenderer(xmlElement); } else if (!(xmlElement.LocalName == "appender")) { SetParameter(xmlElement, m_hierarchy); } } } string attribute5 = element.GetAttribute("threshold"); LogLog.Debug(declaringType, "Hierarchy Threshold [" + attribute5 + "]"); if (attribute5.Length > 0 && attribute5 != "null") { Level level = (Level)ConvertStringTo(typeof(Level), attribute5); if (level != null) { m_hierarchy.Threshold = level; } else { LogLog.Warn(declaringType, "Unable to set hierarchy threshold using value [" + attribute5 + "] (with acceptable conversion types)"); } } }
/// <summary> /// Convert string option into an arrangement using <see cref="ConverterRegistry.GetConvertFrom"/> /// </summary> /// <param name="option">pattern, see <seealso cref="ConvertFrom"/> for more info on formatting</param> /// <returns>the arrangement instance</returns> protected static IArrangement GetArrangementInternal(string option) { var arrangement = OptionConverter.ConvertStringTo(typeof(IArrangement), option) as IArrangement; return(arrangement); }
protected object CreateObjectFromXml(XmlElement element, Type defaultTargetType, Type typeConstraint) { Type c = null; string attribute = element.GetAttribute("type"); if ((attribute == null) || (attribute.Length == 0)) { if (defaultTargetType == null) { LogLog.Error(declaringType, "Object type not specified. Cannot create object of type [" + typeConstraint.FullName + "]. Missing Value or Type."); return(null); } c = defaultTargetType; } else { try { c = SystemInfo.GetTypeFromString(attribute, true, true); } catch (Exception exception) { LogLog.Error(declaringType, "Failed to find type [" + attribute + "]", exception); return(null); } } bool flag = false; if ((typeConstraint != null) && !typeConstraint.IsAssignableFrom(c)) { if (!OptionConverter.CanConvertTypeTo(c, typeConstraint)) { string[] textArray1 = new string[] { "Object type [", c.FullName, "] is not assignable to type [", typeConstraint.FullName, "]. There are no acceptable type conversions." }; LogLog.Error(declaringType, string.Concat(textArray1)); return(null); } flag = true; } object target = null; try { target = Activator.CreateInstance(c); } catch (Exception exception2) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Failed to construct object of type [" + c.FullName + "] Exception: " + exception2.ToString()); } IEnumerator enumerator = element.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { XmlNode current = (XmlNode)enumerator.Current; if (current.NodeType == XmlNodeType.Element) { this.SetParameter((XmlElement)current, target); } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } IOptionHandler handler = target as IOptionHandler; if (handler != null) { handler.ActivateOptions(); } return(!flag ? target : OptionConverter.ConvertTypeTo(target, typeConstraint)); }
/// <summary> /// Configure the hierarchy by parsing a DOM tree of XML elements. /// </summary> /// <param name="element">The root element to parse.</param> /// <remarks> /// <para> /// Configure the hierarchy by parsing a DOM tree of XML elements. /// </para> /// </remarks> public void Configure(XmlElement element) { if (element == null || m_hierarchy == null) { return; } string rootElementName = element.LocalName; if (rootElementName != CONFIGURATION_TAG) { LogLog.Error(declaringType, "Xml element is - not a <" + CONFIGURATION_TAG + "> element."); return; } if (!LogLog.EmitInternalMessages) { // Look for a emitDebug attribute to enable internal debug string emitDebugAttribute = element.GetAttribute(EMIT_INTERNAL_DEBUG_ATTR); LogLog.Debug(declaringType, EMIT_INTERNAL_DEBUG_ATTR + " attribute [" + emitDebugAttribute + "]."); if (emitDebugAttribute.Length > 0 && emitDebugAttribute != "null") { LogLog.EmitInternalMessages = OptionConverter.ToBoolean(emitDebugAttribute, true); } else { LogLog.Debug(declaringType, "Ignoring " + EMIT_INTERNAL_DEBUG_ATTR + " attribute."); } } if (!LogLog.InternalDebugging) { // Look for a debug attribute to enable internal debug string debugAttribute = element.GetAttribute(INTERNAL_DEBUG_ATTR); LogLog.Debug(declaringType, INTERNAL_DEBUG_ATTR + " attribute [" + debugAttribute + "]."); if (debugAttribute.Length > 0 && debugAttribute != "null") { LogLog.InternalDebugging = OptionConverter.ToBoolean(debugAttribute, true); } else { LogLog.Debug(declaringType, "Ignoring " + INTERNAL_DEBUG_ATTR + " attribute."); } string confDebug = element.GetAttribute(CONFIG_DEBUG_ATTR); if (confDebug.Length > 0 && confDebug != "null") { LogLog.Warn(declaringType, "The \"" + CONFIG_DEBUG_ATTR + "\" attribute is deprecated."); LogLog.Warn(declaringType, "Use the \"" + INTERNAL_DEBUG_ATTR + "\" attribute instead."); LogLog.InternalDebugging = OptionConverter.ToBoolean(confDebug, true); } } // Default mode is merge ConfigUpdateMode configUpdateMode = ConfigUpdateMode.Merge; // Look for the config update attribute string configUpdateModeAttribute = element.GetAttribute(CONFIG_UPDATE_MODE_ATTR); if (configUpdateModeAttribute != null && configUpdateModeAttribute.Length > 0) { // Parse the attribute try { configUpdateMode = (ConfigUpdateMode)OptionConverter.ConvertStringTo(typeof(ConfigUpdateMode), configUpdateModeAttribute); } catch { LogLog.Error(declaringType, "Invalid " + CONFIG_UPDATE_MODE_ATTR + " attribute value [" + configUpdateModeAttribute + "]"); } } // IMPL: The IFormatProvider argument to Enum.ToString() is deprecated in .NET 2.0 LogLog.Debug(declaringType, "Configuration update mode [" + configUpdateMode.ToString() + "]."); // Only reset configuration if overwrite flag specified if (configUpdateMode == ConfigUpdateMode.Overwrite) { // Reset to original unset configuration m_hierarchy.ResetConfiguration(); LogLog.Debug(declaringType, "Configuration reset before reading config."); } /* Building Appender objects, placing them in a local namespace * for future reference */ /* Process all the top level elements */ foreach (XmlNode currentNode in element.ChildNodes) { if (currentNode.NodeType == XmlNodeType.Element) { XmlElement currentElement = (XmlElement)currentNode; if (currentElement.LocalName == LOGGER_TAG) { ParseLogger(currentElement); } else if (currentElement.LocalName == CATEGORY_TAG) { // TODO: deprecated use of category ParseLogger(currentElement); } else if (currentElement.LocalName == ROOT_TAG) { ParseRoot(currentElement); } else if (currentElement.LocalName == RENDERER_TAG) { ParseRenderer(currentElement); } else if (currentElement.LocalName == APPENDER_TAG) { // We ignore appenders in this pass. They will // be found and loaded if they are referenced. } else { // Read the param tags and set properties on the hierarchy SetParameter(currentElement, m_hierarchy); } } } // Lastly set the hierarchy threshold string thresholdStr = element.GetAttribute(THRESHOLD_ATTR); LogLog.Debug(declaringType, "Hierarchy Threshold [" + thresholdStr + "]"); if (thresholdStr.Length > 0 && thresholdStr != "null") { Level thresholdLevel = (Level)ConvertStringTo(typeof(Level), thresholdStr); if (thresholdLevel != null) { m_hierarchy.Threshold = thresholdLevel; } else { LogLog.Warn(declaringType, "Unable to set hierarchy threshold using value [" + thresholdStr + "] (with acceptable conversion types)"); } } // Done reading config }
/// <summary> /// Creates an object as specified in XML. /// </summary> /// <param name="element">The XML element that contains the definition of the object.</param> /// <param name="defaultTargetType">The object type to use if not explicitly specified.</param> /// <param name="typeConstraint">The type that the returned object must be or must inherit from.</param> /// <returns>The object or <c>null</c></returns> protected object CreateObjectFromXml(XmlElement element, Type defaultTargetType, Type typeConstraint) { Type objectType = null; // Get the object type string objectTypeString = element.GetAttribute(TYPE_ATTR); if (objectTypeString == null || objectTypeString.Length == 0) { if (defaultTargetType == null) { LogLog.Error("DOMConfigurator: Object type not specified. Cannot create object."); return(null); } else { // Use the default object type objectType = defaultTargetType; } } else { // Read the explicit object type try { objectType = SystemInfo.GetTypeFromString(objectTypeString, true, true); } catch (Exception ex) { LogLog.Error("DOMConfigurator: Failed to find type [" + objectTypeString + "]", ex); return(null); } } bool requiresConversion = false; // Got the object type. Check that it meets the typeConstraint if (typeConstraint != null) { if (!typeConstraint.IsAssignableFrom(objectType)) { // Check if there is an appropriate type converter if (OptionConverter.CanConvertTypeTo(objectType, typeConstraint)) { requiresConversion = true; } else { LogLog.Error("DOMConfigurator: Object type [" + objectType.FullName + "] is not assignable to type [" + typeConstraint.FullName + "]. There are no acceptable type convertions."); return(null); } } } // Look for the default constructor ConstructorInfo constInfo = objectType.GetConstructor(SystemInfo.EmptyTypes); if (constInfo == null) { LogLog.Error("DOMConfigurator: Failed to find default constructor for type [" + objectType.FullName + "]"); return(null); } // Call the constructor object createdObject = constInfo.Invoke(BindingFlags.Public | BindingFlags.Instance, null, new object[0], CultureInfo.InvariantCulture); // Set any params on object foreach (XmlNode currentNode in element.ChildNodes) { if (currentNode.NodeType == XmlNodeType.Element) { SetParameter((XmlElement)currentNode, createdObject); } } // Check if we need to call ActivateOptions if (createdObject is IOptionHandler) { ((IOptionHandler)createdObject).ActivateOptions(); } // Ok object should be initialised if (requiresConversion) { // Convert the object type return(OptionConverter.ConvertTypeTo(createdObject, typeConstraint)); } else { // The object is of the correct type return(createdObject); } }
/// <summary> /// Creates an object as specified in XML. /// </summary> /// <param name="element">The XML element that contains the definition of the object.</param> /// <param name="defaultTargetType">The object type to use if not explicitly specified.</param> /// <param name="typeConstraint">The type that the returned object must be or must inherit from.</param> /// <returns>The object or <c>null</c></returns> /// <remarks> /// <para> /// Parse an XML element and create an object instance based on the configuration /// data. /// </para> /// <para> /// The type of the instance may be specified in the XML. If not /// specified then the <paramref name="defaultTargetType"/> is used /// as the type. However the type is specified it must support the /// <paramref name="typeConstraint"/> type. /// </para> /// </remarks> protected object CreateObjectFromXml(XmlElement element, Type defaultTargetType, Type typeConstraint) { Type objectType = null; // Get the object type string objectTypeString = element.GetAttribute(TYPE_ATTR); if (objectTypeString == null || objectTypeString.Length == 0) { if (defaultTargetType == null) { LogLog.Error(declaringType, "Object type not specified. Cannot create object of type [" + typeConstraint.FullName + "]. Missing Value or Type."); return(null); } else { // Use the default object type objectType = defaultTargetType; } } else { // Read the explicit object type try { objectType = SystemInfo.GetTypeFromString(objectTypeString, true, true); } catch (Exception ex) { LogLog.Error(declaringType, "Failed to find type [" + objectTypeString + "]", ex); return(null); } } bool requiresConversion = false; // Got the object type. Check that it meets the typeConstraint if (typeConstraint != null) { if (!typeConstraint.IsAssignableFrom(objectType)) { // Check if there is an appropriate type converter if (OptionConverter.CanConvertTypeTo(objectType, typeConstraint)) { requiresConversion = true; } else { LogLog.Error(declaringType, "Object type [" + objectType.FullName + "] is not assignable to type [" + typeConstraint.FullName + "]. There are no acceptable type conversions."); return(null); } } } // Create using the default constructor object createdObject = null; try { createdObject = Activator.CreateInstance(objectType); } catch (Exception createInstanceEx) { LogLog.Error(declaringType, "XmlHierarchyConfigurator: Failed to construct object of type [" + objectType.FullName + "] Exception: " + createInstanceEx.ToString()); } // Set any params on object foreach (XmlNode currentNode in element.ChildNodes) { if (currentNode.NodeType == XmlNodeType.Element) { SetParameter((XmlElement)currentNode, createdObject); } } // Check if we need to call ActivateOptions IOptionHandler optionHandler = createdObject as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } // Ok object should be initialized if (requiresConversion) { // Convert the object type return(OptionConverter.ConvertTypeTo(createdObject, typeConstraint)); } else { // The object is of the correct type return(createdObject); } }
/// <summary> /// Configure the hierarchy by parsing a DOM tree of XML elements. /// </summary> /// <param name="element">The root element to parse.</param> /// <remarks> /// <para> /// Configure the hierarchy by parsing a DOM tree of XML elements. /// </para> /// </remarks> public void Configure(XmlElement element) { if (element == null || m_hierarchy == null) { return; } string rootelementname = element.LocalName; if (rootelementname != CONFIGURATION_TAG) { LogLog.Error(declaringType, "Xml element is - not a <" + CONFIGURATION_TAG + "> element."); return; } string quietModeAttribute = element.GetAttribute(QUIETMODE_ATTR); LogLog.Debug(declaringType, QUIETMODE_ATTR + " attribute [" + quietModeAttribute + "]."); if (quietModeAttribute.Length > 0 && quietModeAttribute != "null") { LogLog.QuietMode = OptionConverter.ToBoolean(quietModeAttribute, false); } else { LogLog.Debug(declaringType, "Ignoring " + QUIETMODE_ATTR + " attribute."); } if (!LogLog.EmitInternalMessages) { // Look for a emitDebug attribute to enable internal debug string emitDebugAttribute = element.GetAttribute(EMIT_INTERNAL_DEBUG_ATTR); LogLog.Debug(declaringType, EMIT_INTERNAL_DEBUG_ATTR + " attribute [" + emitDebugAttribute + "]."); if (emitDebugAttribute.Length > 0 && emitDebugAttribute != "null") { LogLog.EmitInternalMessages = OptionConverter.ToBoolean(emitDebugAttribute, true); } else { LogLog.Debug(declaringType, "Ignoring " + EMIT_INTERNAL_DEBUG_ATTR + " attribute."); } } if (!LogLog.InternalDebugging) { // Look for a debug attribute to enable internal debug string debugAttribute = element.GetAttribute(INTERNAL_DEBUG_ATTR); LogLog.Debug(declaringType, INTERNAL_DEBUG_ATTR + " attribute [" + debugAttribute + "]."); if (debugAttribute.Length > 0 && debugAttribute != "null") { LogLog.InternalDebugging = OptionConverter.ToBoolean(debugAttribute, true); } else { LogLog.Debug(declaringType, "Ignoring " + INTERNAL_DEBUG_ATTR + " attribute."); } } foreach (XmlNode node in element.ChildNodes) { if (node.NodeType != XmlNodeType.Element) { continue; } XmlElement xe = (XmlElement)node; if (xe.LocalName == LOGGER_TAG) { ParseLogger(xe); } else if (xe.LocalName == APPENDER_TAG) { //.... } else if (xe.LocalName == PLUGINS) { ParsePlugins(xe); } else { SetParameter(xe, m_hierarchy); } } //if (rootelementname != }