/// <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.ToString() + "]"); ConverterInfo converterInfo = (ConverterInfo)m_patternConverters[converterName]; if (converterInfo == null) { LogLog.Error(declaringType, "Unknown converter name [" + converterName + "] in conversion pattern."); return; } PatternConverter patternConverter = null; try { patternConverter = (PatternConverter)Activator.CreateInstance(converterInfo.Type); } catch (Exception ex) { LogLog.Error(declaringType, "Failed to create instance of Type [" + converterInfo.Type.FullName + "] using default constructor. Exception: " + ex.ToString()); } patternConverter.FormattingInfo = formattingInfo; patternConverter.Option = option; patternConverter.Properties = converterInfo.Properties; (patternConverter as IOptionHandler)?.ActivateOptions(); AddConverter(patternConverter); }
public void AddConverter(ConverterInfo converterInfo) { if (converterInfo == null) { throw new ArgumentNullException("converterInfo"); } if (!typeof(PatternConverter).IsAssignableFrom(converterInfo.Type)) { throw new ArgumentException("The converter type specified [" + converterInfo.Type + "] must be a subclass of log4net.Util.PatternConverter", "converterInfo"); } this.m_instanceRulesRegistry[converterInfo.Name] = converterInfo; }
protected override log4net.Util.PatternParser CreatePatternParser(string pattern) { var parser = base.CreatePatternParser(pattern); foreach (DictionaryEntry entry in s_rulesRegistry) { var converterInfo = new ConverterInfo { Name = (string)entry.Key, Type = (Type)entry.Value }; parser.PatternConverters[entry.Key] = converterInfo; } return parser; }
/// <summary> /// Add a converter to this PatternString /// </summary> /// <param name="name">the name of the conversion pattern for this converter</param> /// <param name="type">the type of the converter</param> /// <remarks> /// <para> /// Add a converter to this PatternString /// </para> /// </remarks> public void AddConverter(string name, Type type) { if (name == null) { throw new ArgumentNullException("name"); } if ((object)type == null) { throw new ArgumentNullException("type"); } ConverterInfo converterInfo = new ConverterInfo(); converterInfo.Name = name; converterInfo.Type = type; AddConverter(converterInfo); }
/// <summary> /// Create the <see cref="T:log4net.Util.PatternParser" /> used to parse the pattern /// </summary> /// <param name="pattern">the pattern to parse</param> /// <returns>The <see cref="T:log4net.Util.PatternParser" /></returns> /// <remarks> /// <para> /// Returns PatternParser used to parse the conversion string. Subclasses /// may override this to return a subclass of PatternParser which recognize /// custom conversion pattern name. /// </para> /// </remarks> private PatternParser CreatePatternParser(string pattern) { PatternParser patternParser = new PatternParser(pattern); foreach (DictionaryEntry item in s_globalRulesRegistry) { ConverterInfo converterInfo = new ConverterInfo(); converterInfo.Name = (string)item.Key; converterInfo.Type = (Type)item.Value; patternParser.PatternConverters.Add(item.Key, converterInfo); } foreach (DictionaryEntry item2 in m_instanceRulesRegistry) { patternParser.PatternConverters[item2.Key] = item2.Value; } return(patternParser); }
public void AddConverter(string name, Type type) { if (name == null) { throw new ArgumentNullException("name"); } if (type == null) { throw new ArgumentNullException("type"); } ConverterInfo converterInfo = new ConverterInfo { Name = name, Type = type }; this.AddConverter(converterInfo); }
private PatternParser CreatePatternParser(string pattern) { PatternParser parser = new PatternParser(pattern); IDictionaryEnumerator enumerator = s_globalRulesRegistry.GetEnumerator(); try { while (enumerator.MoveNext()) { DictionaryEntry current = (DictionaryEntry)enumerator.Current; ConverterInfo info = new ConverterInfo { Name = (string)current.Key, Type = (Type)current.Value }; parser.PatternConverters.Add(current.Key, info); } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } IDictionaryEnumerator enumerator2 = this.m_instanceRulesRegistry.GetEnumerator(); try { while (enumerator2.MoveNext()) { DictionaryEntry current = (DictionaryEntry)enumerator2.Current; parser.PatternConverters[current.Key] = current.Value; } } finally { IDisposable disposable2 = enumerator2 as IDisposable; if (disposable2 != null) { disposable2.Dispose(); } } return(parser); }
/// <summary> /// Creates the pattern parser. /// </summary> /// <param name="pattern">The pattern.</param> /// <returns></returns> virtual protected PatternParser CreatePatternParser(string pattern) { PatternParser parser = new PatternParser(pattern); foreach (DictionaryEntry entry in s_globalRulesRegistry) { log4net.Util.ConverterInfo converterInfo = new log4net.Util.ConverterInfo(); converterInfo.Name = (string)entry.Key; converterInfo.Type = (Type)entry.Value; parser.PatternConverters[entry.Key] = converterInfo; //parser.PatternConverters[entry.Key] = entry.Value; } foreach (DictionaryEntry entry in m_instanceRulesRegistry) { parser.PatternConverters[entry.Key] = entry.Value; } return(parser); }
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> /// Create the <see cref="PatternParser"/> used to parse the pattern /// </summary> /// <param name="pattern">the pattern to parse</param> /// <returns>The <see cref="PatternParser"/></returns> /// <remarks> /// <para> /// Returns PatternParser used to parse the conversion string. Subclasses /// may override this to return a subclass of PatternParser which recognize /// custom conversion pattern name. /// </para> /// </remarks> private PatternParser CreatePatternParser(string pattern) { PatternParser patternParser = new PatternParser(pattern); // Add all the builtin patterns foreach (DictionaryEntry entry in s_globalRulesRegistry) { ConverterInfo converterInfo = new ConverterInfo(); converterInfo.Name = (string)entry.Key; converterInfo.Type = (Type)entry.Value; patternParser.PatternConverters.Add(entry.Key, converterInfo); } // Add the instance patterns foreach (DictionaryEntry entry in m_instanceRulesRegistry) { patternParser.PatternConverters[entry.Key] = entry.Value; } return(patternParser); }
/// <summary> /// Add a converter to this PatternLayout /// </summary> /// <param name="converterInfo">the converter info</param> /// <remarks> /// <para> /// This version of the method is used by the configurator. /// Programmatic users should use the alternative <see cref="AddConverter(string,Type)"/> method. /// </para> /// </remarks> public void AddConverter(ConverterInfo converterInfo) { AddConverter(converterInfo.Name, converterInfo.Type); }
/// <summary> /// Add a converter to this PatternLayout /// </summary> /// <param name="name">the name of the conversion pattern for this converter</param> /// <param name="type">the type of the converter</param> /// <remarks> /// <para> /// Add a named pattern converter to this instance. This /// converter will be used in the formatting of the event. /// This method must be called before <see cref="ActivateOptions"/>. /// </para> /// <para> /// The <paramref name="type"/> specified must extend the /// <see cref="PatternConverter"/> type. /// </para> /// </remarks> public void AddConverter(string name, Type type) { if (name == null) throw new ArgumentNullException("name"); if (type == null) throw new ArgumentNullException("type"); ConverterInfo converterInfo = new ConverterInfo(); converterInfo.Name = name; converterInfo.Type = type; AddConverter(converterInfo); }
/// <summary> /// Add a converter to this PatternLayout /// </summary> /// <param name="converterInfo">the converter info</param> /// <remarks> /// <para> /// This version of the method is used by the configurator. /// Programmatic users should use the alternative <see cref="AddConverter(string,Type)"/> method. /// </para> /// </remarks> public void AddConverter(ConverterInfo converterInfo) { if (converterInfo == null) throw new ArgumentNullException("converterInfo"); if (!typeof(PatternConverter).IsAssignableFrom(converterInfo.Type)) { throw new ArgumentException("The converter type specified [" + converterInfo.Type + "] must be a subclass of log4net.Util.PatternConverter", "converterInfo"); } m_instanceRulesRegistry[converterInfo.Name] = converterInfo; }
/// <summary> /// Create the pattern parser instance /// </summary> /// <param name="pattern">the pattern to parse</param> /// <returns>The <see cref="PatternParser"/> that will format the event</returns> /// <remarks> /// <para> /// Creates the <see cref="PatternParser"/> used to parse the conversion string. Sets the /// global and instance rules on the <see cref="PatternParser"/>. /// </para> /// </remarks> virtual protected PatternParser CreatePatternParser(string pattern) { PatternParser patternParser = new PatternParser(pattern); // Add all the builtin patterns foreach(DictionaryEntry entry in s_globalRulesRegistry) { ConverterInfo converterInfo = new ConverterInfo(); converterInfo.Name = (string)entry.Key; converterInfo.Type = (Type)entry.Value; patternParser.PatternConverters[entry.Key] = converterInfo; } // Add the instance patterns foreach(DictionaryEntry entry in m_instanceRulesRegistry) { patternParser.PatternConverters[entry.Key] = entry.Value; } return patternParser; }
/// <summary> /// Add a converter to this PatternString /// </summary> /// <param name="converterInfo">the converter info</param> /// <remarks> /// <para> /// This version of the method is used by the configurator. /// Programmatic users should use the alternative <see cref="AddConverter(string,Type)"/> method. /// </para> /// </remarks> public void AddConverter(ConverterInfo converterInfo) { AddConverter(converterInfo.Name, converterInfo.Type); }
public void AddConverter(ConverterInfo converterInfo) { m_converters.Add(converterInfo); }