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