/// <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);
}
