/// <summary> /// create plugin /// </summary> private IPlugin ParsePlugin(XmlElement pluginElement) { string appenderName = pluginElement.GetAttribute(NAME_ATTR); string typeName = pluginElement.GetAttribute(TYPE_ATTR); try { IPlugin plugin = (IPlugin)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true)); foreach (XmlNode currnode in pluginElement.ChildNodes) { if (currnode.NodeType != XmlNodeType.Element) { continue; } SetParameter((XmlElement)currnode, plugin); } IOptionHandler optionHandler = plugin as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } LogLog.Debug(declaringType, "Created Appender [" + appenderName + "]"); return(plugin); } catch (Exception ex) { // Yes, it's ugly. But all exceptions point to the same problem: we can't create an Appender LogLog.Error(declaringType, "Could not create Plugin [" + appenderName + "] of type [" + typeName + "]. Reported error follows.", ex); return(null); } }
/// <summary> /// Activate component options /// </summary> /// <remarks> /// <para> /// This is part of the <see cref="IOptionHandler"/> delayed object /// activation scheme. The <see cref="ActivateOptions"/> method must /// be called on this object after the configuration properties have /// been set. Until <see cref="ActivateOptions"/> is called this /// object is in an undefined state and must not be used. /// </para> /// <para> /// If any of the configuration properties are modified then /// <see cref="ActivateOptions"/> must be called again. /// </para> /// <para> /// This method must be implemented by the subclass. /// </para> /// </remarks> public virtual void ActivateOptions() { IOptionHandler optionHandler = m_nestedLayout as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } }
protected void ParseChildrenOfLoggerElement(XmlElement catElement, Logger log, bool isRoot) { log.RemoveAllAppenders(); IEnumerator enumerator = catElement.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { XmlNode current = (XmlNode)enumerator.Current; if (current.NodeType == XmlNodeType.Element) { XmlElement element = (XmlElement)current; if (element.LocalName != "appender-ref") { if ((element.LocalName != "level") && (element.LocalName != "priority")) { this.SetParameter(element, log); continue; } this.ParseLevel(element, log, isRoot); continue; } IAppender newAppender = this.FindAppenderByReference(element); string attribute = element.GetAttribute("ref"); if (newAppender == null) { LogLog.Error(declaringType, "Appender named [" + attribute + "] not found."); continue; } string[] textArray1 = new string[] { "Adding appender named [", attribute, "] to logger [", log.Name, "]." }; LogLog.Debug(declaringType, string.Concat(textArray1)); log.AddAppender(newAppender); } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } IOptionHandler handler = log as IOptionHandler; if (handler != null) { handler.ActivateOptions(); } }
/// <summary> /// Add <see cref="PatternConverter.Properties"/>, /// call <see cref="IOptionHandler.ActivateOptions"/> /// </summary> /// <param name="conv">serializer to be set up</param> /// <param name="converters">converters to be used collected from parent class</param> /// <param name="arrangement">arrangement to be used collected from parent class</param> /// <param name="fetcher">fetcher to use</param> /// <param name="renderer">renderer to use</param> /// <param name="decorators">decorators to use</param> /// <remarks> /// <para> /// Please note that properties are only supported with log4net 1.2.11 and above. /// </para> /// </remarks> protected virtual void SetUpSerializingConverter(PatternConverter conv, ConverterInfo[] converters, IArrangement arrangement, IRawLayout fetcher, IObjectRenderer renderer, IDecorator[] decorators) { conv.Properties["arrangement"] = arrangement; conv.Properties["converters"] = converters; conv.Properties["fetcher"] = fetcher; conv.Properties["renderer"] = renderer; conv.Properties["decorators"] = decorators; IOptionHandler optionHandler = conv as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } }
/// <summary> /// Parses the children of a logger element. /// </summary> /// <param name="catElement">The category element.</param> /// <param name="log">The logger instance.</param> /// <param name="isRoot">Flag to indicate if the logger is the root logger.</param> /// <remarks> /// <para> /// Parse the child elements of a <logger> element. /// </para> /// </remarks> protected void ParseChildrenOfLoggerElement(XmlElement catElement, Logger log, bool isRoot) { // Remove all existing appenders from log. They will be // reconstructed if need be. log.RemoveAllAppenders(); foreach (XmlNode currentNode in catElement.ChildNodes) { if (currentNode.NodeType == XmlNodeType.Element) { XmlElement currentElement = (XmlElement)currentNode; if (currentElement.LocalName == APPENDER_REF_TAG) { IAppender appender = FindAppenderByReference(currentElement); string refName = currentElement.GetAttribute(REF_ATTR); if (appender != null) { LogLog.Debug(declaringType, "Adding appender named [" + refName + "] to logger [" + log.Name + "]."); log.AddAppender(appender); } else { LogLog.Error(declaringType, "Appender named [" + refName + "] not found."); } } else if (currentElement.LocalName == LEVEL_TAG || currentElement.LocalName == PRIORITY_TAG) { ParseLevel(currentElement, log, isRoot); } else { SetParameter(currentElement, log); } } } IOptionHandler optionHandler = log as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } }
/// <summary> /// Process a parsed converter pattern /// </summary> /// <param name="converterName">the name of the converter</param> /// <param name="option">the optional option for the converter</param> /// <param name="formattingInfo">the formatting info for the converter</param> private void ProcessConverter(string converterNameSrc) { string option, converterName; ParseOption(converterNameSrc, out converterName, out option); converterName = converterName.TrimStart(new char[] { ESCAPE_CHAR }); LogLog.Debug(declaringType, "Converter [" + converterName + "] Option [" + option + "]"); // Lookup the converter type Type type = (Type)s_globalRulesRegistry[converterName]; if (type == null) { type = (Type)s_globalRulesRegistry["literal"]; option = converterName; } if (type == null) { LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern."); } else { // Create the pattern converter PatternConverter pc = null; try { pc = (PatternConverter)Activator.CreateInstance(type); } catch (Exception createInstanceEx) { LogLog.Error(declaringType, "Failed to create instance of Type [" + type.FullName + "] using default constructor. Exception: " + createInstanceEx.ToString()); } pc.Option = option; IOptionHandler optionHandler = pc as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } AddConverter(pc); } }
private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo) { object[] objArray1 = new object[11]; objArray1[0] = "Converter ["; objArray1[1] = converterName; objArray1[2] = "] Option ["; objArray1[3] = option; objArray1[4] = "] Format [min="; objArray1[5] = formattingInfo.Min; objArray1[6] = ",max="; objArray1[7] = formattingInfo.Max; objArray1[8] = ",leftAlign="; objArray1[9] = formattingInfo.LeftAlign; objArray1[10] = "]"; LogLog.Debug(declaringType, string.Concat(objArray1)); ConverterInfo info = (ConverterInfo)this.m_patternConverters[converterName]; if (info == null) { LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern."); } else { PatternConverter pc = null; try { pc = (PatternConverter)Activator.CreateInstance(info.Type); } catch (Exception exception) { LogLog.Error(declaringType, "Failed to create instance of Type [" + info.Type.FullName + "] using default constructor. Exception: " + exception.ToString()); } pc.FormattingInfo = formattingInfo; pc.Option = option; pc.Properties = info.Properties; IOptionHandler handler = pc as IOptionHandler; if (handler != null) { handler.ActivateOptions(); } this.AddConverter(pc); } }
/// <summary> /// Process a parsed converter pattern /// 处理已解析的转换器模式 /// </summary> /// <param name="converterName">the name of the converter</param> /// <param name="option">the optional option for the converter</param> /// <param name="formattingInfo">the formatting info for the converter</param> private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo) { LogLog.Debug(declaringType, "Converter [" + converterName + "] Option [" + option + "] Format [min=" + formattingInfo.Min + ",max=" + formattingInfo.Max + ",leftAlign=" + formattingInfo.LeftAlign + "]"); // Lookup the converter type ConverterInfo converterInfo = (ConverterInfo)m_patternConverters[converterName]; if (converterInfo == null) { //未知的转换器 LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern."); } else { // Create the pattern converter // 创建模式转换器 PatternConverter pc = null; try { pc = (PatternConverter)Activator.CreateInstance(converterInfo.Type); } catch (Exception createInstanceEx) { LogLog.Error(declaringType, "Failed to create instance of Type [" + converterInfo.Type.FullName + "] using default constructor. Exception: " + createInstanceEx.ToString()); } // formattingInfo variable is an instance variable, occasionally reset and used over and over again // formattingInfo变量是一个实例变量,偶尔会重新设置并反复使用 pc.FormattingInfo = formattingInfo; pc.Option = option; pc.Properties = converterInfo.Properties; IOptionHandler optionHandler = pc as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } AddConverter(pc); } }
/// <summary> /// Parses an appender element. /// </summary> /// <param name="appenderElement">The appender element.</param> /// <returns>The appender instance or <c>null</c> when parsing failed.</returns> /// <remarks> /// <para> /// Parse an XML element that represents an appender and return /// the appender instance. /// </para> /// </remarks> protected IAppender ParseAppender(XmlElement appenderelement) { string appenderName = appenderelement.GetAttribute(NAME_ATTR); string typeName = appenderelement.GetAttribute(TYPE_ATTR); try { IAppender appender = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true)); appender.Name = appenderName; foreach (XmlNode currnode in appenderelement.ChildNodes) { if (currnode.NodeType != XmlNodeType.Element) { continue; } if (currnode.LocalName == APPENDER_REF_TAG) { } else { SetParameter((XmlElement)currnode, appender); } } IOptionHandler optionHandler = appender as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } LogLog.Debug(declaringType, "Created Appender [" + appenderName + "]"); return(appender); } catch (Exception ex) { // Yes, it's ugly. But all exceptions point to the same problem: we can't create an Appender LogLog.Error(declaringType, "Could not create Appender [" + appenderName + "] of type [" + typeName + "]. Reported error follows.", ex); return(null); } }
/// <summary> /// Process a parsed converter pattern /// </summary> /// <param name="converterName">the name of the converter</param> /// <param name="option">the optional option for the converter</param> /// <param name="formattingInfo">the formatting info for the converter</param> private void ProcessConverter(string converterName, string option, FormattingInfo formattingInfo) { LogLog.Trace("PatternParser: Converter [" + converterName + "] Option [" + option + "] Format [min=" + formattingInfo.Min + ",max=" + formattingInfo.Max + ",leftAlign=" + formattingInfo.LeftAlign + "]"); // Lookup the converter type Type converterType = (Type)m_patternConverters[converterName]; if (converterType == null) { LogLog.Error("PatternParser: Unknown converter name [" + converterName + "] in conversion pattern."); } else { // Create the pattern converter PatternConverter pc = null; try { pc = (PatternConverter)Activator.CreateInstance(converterType); // formattingInfo variable is an instance variable, occasionally reset // and used over and over again pc.FormattingInfo = formattingInfo; pc.Option = option; IOptionHandler optionHandler = pc as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } AddConverter(pc); } catch (Exception createInstanceEx) { LogLog.Error("PatternParser: Failed to create instance of Type [" + converterType.FullName + "] using default constructor. Exception: " + createInstanceEx.ToString()); } } }
/// <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> /// Parses an appender element. /// </summary> /// <param name="appenderElement">The appender element.</param> /// <returns>The appender instance or <c>null</c> when parsing failed.</returns> /// <remarks> /// <para> /// Parse an XML element that represents an appender and return /// the appender instance. /// </para> /// </remarks> protected IAppender ParseAppender(XmlElement appenderElement) { string appenderName = appenderElement.GetAttribute(NAME_ATTR); string typeName = appenderElement.GetAttribute(TYPE_ATTR); LogLog.Debug(declaringType, "Loading Appender [" + appenderName + "] type: [" + typeName + "]"); try { IAppender appender = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true)); appender.Name = appenderName; foreach (XmlNode currentNode in appenderElement.ChildNodes) { /* We're only interested in Elements */ if (currentNode.NodeType == XmlNodeType.Element) { XmlElement currentElement = (XmlElement)currentNode; // Look for the appender ref tag if (currentElement.LocalName == APPENDER_REF_TAG) { string refName = currentElement.GetAttribute(REF_ATTR); IAppenderAttachable appenderContainer = appender as IAppenderAttachable; if (appenderContainer != null) { LogLog.Debug(declaringType, "Attaching appender named [" + refName + "] to appender named [" + appender.Name + "]."); IAppender referencedAppender = FindAppenderByReference(currentElement); if (referencedAppender != null) { appenderContainer.AddAppender(referencedAppender); } } else { LogLog.Error(declaringType, "Requesting attachment of appender named [" + refName + "] to appender named [" + appender.Name + "] which does not implement log4net.Core.IAppenderAttachable."); } } else { // For all other tags we use standard set param method SetParameter(currentElement, appender); } } } IOptionHandler optionHandler = appender as IOptionHandler; if (optionHandler != null) { optionHandler.ActivateOptions(); } LogLog.Debug(declaringType, "Created Appender [" + appenderName + "]"); return(appender); } catch (Exception ex) { // Yes, it's ugly. But all exceptions point to the same problem: we can't create an Appender LogLog.Error(declaringType, "Could not create Appender [" + appenderName + "] of type [" + typeName + "]. Reported error follows.", ex); return(null); } }
/// <summary> /// Activate a setting instance /// </summary> /// <param name="optionHandler"></param> private static void ActivateOptions(IOptionHandler optionHandler) { optionHandler.ActivateOptions(); }
public CommandLineHelper <TOptions> WithOptionHandler(IOptionHandler handler) { _handlers.Add(handler); return(this); }
protected IAppender ParseAppender(XmlElement appenderElement) { string attribute = appenderElement.GetAttribute("name"); string typeName = appenderElement.GetAttribute("type"); string[] textArray1 = new string[] { "Loading Appender [", attribute, "] type: [", typeName, "]" }; LogLog.Debug(declaringType, string.Concat(textArray1)); try { IAppender target = (IAppender)Activator.CreateInstance(SystemInfo.GetTypeFromString(typeName, true, true)); target.Name = attribute; IEnumerator enumerator = appenderElement.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { XmlNode current = (XmlNode)enumerator.Current; if (current.NodeType == XmlNodeType.Element) { XmlElement element = (XmlElement)current; if (element.LocalName != "appender-ref") { this.SetParameter(element, target); continue; } string str3 = element.GetAttribute("ref"); IAppenderAttachable attachable = target as IAppenderAttachable; if (attachable == null) { string[] textArray3 = new string[] { "Requesting attachment of appender named [", str3, "] to appender named [", target.Name, "] which does not implement log4net.Core.IAppenderAttachable." }; LogLog.Error(declaringType, string.Concat(textArray3)); continue; } string[] textArray2 = new string[] { "Attaching appender named [", str3, "] to appender named [", target.Name, "]." }; LogLog.Debug(declaringType, string.Concat(textArray2)); IAppender appender2 = this.FindAppenderByReference(element); if (appender2 != null) { attachable.AddAppender(appender2); } } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } IOptionHandler handler = target as IOptionHandler; if (handler != null) { handler.ActivateOptions(); } LogLog.Debug(declaringType, "Created Appender [" + attribute + "]"); return(target); } catch (Exception exception) { string[] textArray4 = new string[] { "Could not create Appender [", attribute, "] of type [", typeName, "]. Reported error follows." }; LogLog.Error(declaringType, string.Concat(textArray4), exception); return(null); } }
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)); }