PCGUIA 2010 Software/Programs/PCGuia_programas.iso/Software/Internet/Orb/Orb20SetupUs.exe/bin/log4net.xml

Extensible Markup Language | 2007-05-01 | 471.6 KB | 9,613 lines

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>log4net</name>
    </assembly>
    <members>
        <member name="T:log4net.Appender.ADONetAppender">
            <summary>
            Appender that logs into a database table
            </summary>
            <remarks>
            <para><see cref="T:log4net.Appender.ADONetAppender"/> appends log events to a table within a
            database.  The appender can be configured to specify
            the connection string by setting the <see cref="P:log4net.Appender.ADONetAppender.ConnectionString"/>
            property. The database INSERT statement used must be configured
            using the <see cref="T:log4net.Layout.ILayout"/> for this appender.</para>
            </remarks>
            <example>Example layout
            <code>
            <layout type="log4net.Layout.PatternLayout,log4net">
                <param name="ConversionPattern" value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES ('%d','%t','%p','%c','%m')" />
            </layout>
            </code>
            </example>
        </member>
        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
            <summary>
            Abstract baseclass implementation of <see cref="T:log4net.Appender.IAppender"/> that
            buffers events in a fixed size buffer.
            </summary>
            <remarks>
            <para>This base class should be used by appenders that need to
            buffer a number of events before logging them. For example the
            <see cref="T:log4net.Appender.SMTPAppender"/> buffers events and then sends the
            entire contents of the buffer in a single email message.</para>

            <para>Subclasses should override the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])"/>
            method to deliver the buffered events.</para>

            <para>The BufferingAppenderSkeleton maintains a fixed size
            cyclic buffer of events. The size of the buffer is set using
            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.</para>

            <para>A <see cref="T:log4net.spi.ITriggeringEventEvaluator"/> is used to
            inspect each event as it arrives in the appender. If the
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> triggers then the current buffer
            is sent immediatly (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])"/>).
            Otherwise the event is stored in the buffer. For example an
            evaulator can be used to deliver the events immedialty
            when an ERROR event arrives.</para>

            <para>The buffering appender can be configured in a
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. By default the appender is
            NOT lossy. When the buffer is full all the buffered
            events are sent with <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])"/>.
            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c>
            then the buffer will not be sent when it is full, and
            new events arriving in the appender will overwrite
            the oldest event in the buffer. In lossy mode the
            buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
            triggers. This can be usefull behaviour when you need
            to know about ERROR events but not about events with a
            lower level, configure an evaluator that will trigger
            when an ERROR event arrives, the whole buffer will be
            sent which gives a history of events leading upto
            the ERROR event.</para>
            </remarks>
        </member>
        <member name="T:log4net.Appender.AppenderSkeleton">
            <summary>
            Abstract baseclass implementation of <see cref="T:log4net.Appender.IAppender"/>.
            </summary>
            <remarks>
            <para>This class provides the code for common functionality, such
            as support for threshold filtering and support for general filters.</para>
            </remarks>
        </member>
        <member name="T:log4net.Appender.IAppender">
            <summary>
            Implement this interface for your own strategies for printing log statements.
            </summary>
            <remarks>
            <para>
            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
            class which provides a default implementation of this interface.
            </para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.IAppender.Close">
            <summary>
            Close the appender and release resources
            </summary>
            <remarks>
            <para>Release any resources allocated within the appender such as file handles,
            network connections, etc.</para>

            <para>It is a programming error to append to a closed appender.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.spi.LoggingEvent)">
            <summary>
            Log in Appender specific way
            </summary>
            <param name="loggingEvent">the event to log</param>
            <remarks>
            <para>This method is called to loag a message into this appender</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.IAppender.RequiresLayout">
            <summary>
            Test if this appender requires a <see cref="P:log4net.Appender.IAppender.Layout"/> to be set
            </summary>
            <remarks>
            <para>Configurators call this method to determine if the appender
            requires a layout. If this method returns <c>true</c>,
            meaning that layout is required, then the configurator will
            configure an layout using the configuration information at
            its disposal.  If this method returns <c>false</c>,
            meaning that a layout is not required, then layout configuration
            will be    skipped even if there is available layout configuration
            information at the disposal of the configurator.</para>

            <para>In the rather exceptional case, where the appender
            implementation admits a layout but can also work without it,
            then the appender should return <c>true</c>.</para>
            </remarks>
            <returns><c>true</c> if the appender requires a layout object, otherwise <c>false</c></returns>
        </member>
        <member name="P:log4net.Appender.IAppender.Filter">
            <summary>
            The filter chain
            </summary>
            <value>
            The head of the filter chain filter chain
            </value>
            <remarks>
            <para>Returns the head Filter. The Filters are organized in a linked list
            and so all Filters on this Appender are available through the result.</para>

            <para>Settings this property causes the new filter to be pushed onto the
            front of the filter chain. To clear all the filters, set this property
            to <c>null</c>.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.IAppender.Name">
            <summary>
            Get the name of this appender. The name uniquely identifies the appender.
            </summary>
            <value>the name of the appender</value>
            <remarks>
            <para>Get the name of this appender. The name uniquely identifies the appender.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.IAppender.ErrorHandler">
            <summary>
            The <see cref="P:log4net.Appender.IAppender.ErrorHandler"/> for this appender.
            </summary>
            <value>The error handler used</value>
            <remarks>
            <para>The <see cref="P:log4net.Appender.IAppender.ErrorHandler"/> for this appender.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.IAppender.Layout">
            <summary>
            The <see cref="T:log4net.Layout.ILayout"/> for this appender.
            </summary>
            <value>The layout to use with the appender</value>
            <remarks>
            <para>The <see cref="T:log4net.Layout.ILayout"/> for this appender.</para>

            <para>See <see cref="M:log4net.Appender.IAppender.RequiresLayout"/> for more information.</para>
            </remarks>
            <seealso cref="M:log4net.Appender.IAppender.RequiresLayout"/>
        </member>
        <member name="T:log4net.spi.IOptionHandler">
            <summary>
            A string based interface to configure components.
            </summary>
        </member>
        <member name="M:log4net.spi.IOptionHandler.ActivateOptions">
            <summary>
            Activate the options that were previously set with calls to option setters.
            </summary>
            <remarks>
            This allows to defer activiation of the options until all
            options have been set. This is required for components which have
            related options that remain ambigous until all are set.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
            <summary>
            The layout variable does not need to be set if the appender implementation has its own layout.
            </summary>
            <remarks>
            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
            <summary>
            The name of this appender.
            </summary>
            <remarks>
            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
            <summary>
            There is no level threshold filtering by default.
            </summary>
            <remarks>
            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
            <summary>
            It is assumed and enforced that errorHandler is never null.
            </summary>
            <remarks>
            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
            <summary>
            The first filter in the filter chain. Set to <c>null</c> initially.
            </summary>
            <remarks>
            See <see cref="P:log4net.Appender.AppenderSkeleton.Filter"/> for more information.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
            <summary>
            The last filter in the filter chain.
            </summary>
            <remarks>
            See <see cref="P:log4net.Appender.AppenderSkeleton.Filter"/> for more information.
            </remarks>
        </member>
        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
            <summary>
            Flag indicating if this appender closed.
            </summary>
            <remarks>
            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
            <summary>
            Default constructor
            </summary>
            <remarks>
            <para>Empty default constructor</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)">
            <summary>
            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method
            to perform actual logging. See also <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/> method.
            </summary>
            <param name="loggingEvent">the event to append</param>
            <remarks>
            <param>A subclass must implement this method to perform
            logging of the <paramref name="loggingEvent"/>.</param>

            <para>This method will be called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/>
            if all the conditions listed for that method are met.</para>

            <para>To restrict the logging of events in the appender
            override the <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> method.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
            <summary>
            Called before <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> as a precondition.
            </summary>
            <returns>true if the call to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> should proceed</returns>
            <remarks>
            <para>This method is called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/>
            before the call to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> method. This
            method can be overriden in a subclass to extend the checks made
            before the event is passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> method.</para>

            <para>A subclass should ensure that they delegate this call to
            this base class if it is overriden.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
            <summary>
            Finalize this appender by calling the implementation's
            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
            </summary>
            <remarks>
            Finalize this appender by calling the implementation's
            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.spi.Level)">
            <summary>
            Check if the message level is below this appender's threshold.
            </summary>
            <param name="level"><see cref="T:log4net.spi.Level"/> to test against</param>
            <returns><c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> requirments of this appender</returns>
            <remarks>
            <para>Check if the message level is below this appender's
            <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/>.</para>

            <para>If there is no threshold set, then the return
            value is always <c>true</c>.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
            <summary>
            Initialise the appender based on the options set
            </summary>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
            <summary>
            Close the appender and release resources
            </summary>
            <remarks>
            <para>Release any resources allocated within the appender such as file handles,
            network connections, etc.</para>

            <para>It is a programming error to append to a closed appender.</para>

            <para>This method is declared <c>virtual</c> in the <see cref="T:log4net.Appender.AppenderSkeleton"/>
            class. This can be overriden by the subclass.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.Close">
            <summary>
            Close the appender and release resources
            </summary>
            <remarks>
            <para>Release any resources allocated within the appender such as file handles,
            network connections, etc.</para>

            <para>It is a programming error to append to a closed appender.</para>

            <para>This method cannot be overriden by subclasses. This method
            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
            method which must be overidden in the subclass.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.RequiresLayout">
            <summary>
            Test if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set
            </summary>
            <remarks>
            <para>Configurators call this method to determine if the appender
            requires a layout. If this method returns <c>true</c>,
            meaning that layout is required, then the configurator will
            configure an layout using the configuration information at
            its disposal.  If this method returns <c>false</c>,
            meaning that a layout is not required, then layout configuration
            will be    skipped even if there is available layout configuration
            information at the disposal of the configurator.</para>

            <para>In the rather exceptional case, where the appender
            implementation admits a layout but can also work without it,
            then the appender should return <c>true</c>.</para>

            <para>This method is declared <c>abstract</c> in the
            <see cref="T:log4net.Appender.AppenderSkeleton"/> class. This must be overriden by the subclass.</para>
            </remarks>
            <returns><c>true</c> if the appender requires a layout object, otherwise <c>false</c></returns>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)">
            <summary>
            This method performs threshold checks and invokes filters
            before delegating actual logging to the subclasses specific
            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> method.
            </summary>
            <param name="loggingEvent">the event to log</param>
            <remarks>
            <para>This method cannot be overriden by the base class. The
            base class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> method
            which this method call.</para>

            <para>The implementation of this method is as follows:</para>
            <list type="bullet">
                <item>
                    <description>Check that the severity of the <paramref name="loggingEvent"/>
                    is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
                    appender.</description>
                </item>
                <item>
                    <description>Check that the <see cref="P:log4net.Appender.AppenderSkeleton.Filter"/> chain accepts
                    the <paramref name="loggingEvent"/>.</description>
                </item>
                <item>
                    <description>Call <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and check that
                    it returns <c>true</c>.</description>
                </item>
            </list>
            <para>If all of the above steps succeed then the <paramref name="loggingEvent"/>
            will be passed to the astract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.spi.LoggingEvent)"/> method.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.spi.LoggingEvent)">
            <summary>
            Render the <see cref="T:log4net.spi.LoggingEvent"/> to a string
            </summary>
            <param name="loggingEvent">the event to render</param>
            <returns>the event rendered as a string</returns>
            <remarks>
            <para>Helper method to render a <see cref="T:log4net.spi.LoggingEvent"/>
            to a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
            set. The <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> will be used to render the
            <paramref name="loggingEvent"/> to a string.</para>

            <para>If there is exception data in the logging event and
            the layout does not process the exception, this method
            will append the exception text to the rendered string.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
            <summary>
            Set the threshold <see cref="T:log4net.spi.Level"/>. All log events with lower level
            than the threshold level are ignored by the appender.
            </summary>
            <value>
            The threshold <see cref="T:log4net.spi.Level"/>. All log events with lower level
            than the threshold level are ignored by the appender.
            </value>
            <remarks>
            <para>In configuration files this option is specified by setting the
            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
            string, such as "DEBUG", "INFO" and so on.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
            <summary>
            The <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for this appender.
            </summary>
            <value>The error handler used</value>
            <remarks>
            <para>The <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for this appender.</para>

            <para>The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default
            implementation of the error handler property. It stores the
            error handler in the <see cref="F:log4net.Appender.AppenderSkeleton.m_errorHandler"/> member
            variable.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.AppenderSkeleton.Filter">
            <summary>
            The filter chain
            </summary>
            <value>
            The head of the filter chain filter chain
            </value>
            <remarks>
            <para>Returns the head Filter. The Filters are organized in a linked list
            and so all Filters on this Appender are available through the result.</para>

            <para>Settings this property causes the new filter to be pushed onto the
            front of the filter chain. To clear all the filters, set this property
            to <c>null</c>.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
            <summary>
            The <see cref="T:log4net.Layout.ILayout"/> for this appender.
            </summary>
            <value>The layout to use with the appender</value>
            <remarks>
            <para>The <see cref="T:log4net.Layout.ILayout"/> for this appender.</para>

            <para>See <see cref="M:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.</para>
            </remarks>
            <seealso cref="M:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
        </member>
        <member name="P:log4net.Appender.AppenderSkeleton.Name">
            <summary>
            Get the name of this appender. The name uniquely identifies the appender.
            </summary>
            <value>the name of the appender</value>
            <remarks>
            <para>Get the name of this appender. The name uniquely identifies the appender.</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
            <summary>
            the default buffer size
            </summary>
            <remarks>
            The default size of the cyclic buffer used to store events.
            This is set to 512 by default.
            </remarks>
        </member>
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
            <summary>
            The buffer size
            </summary>
            <remarks>
            The size of the cyclic buffer used to hold the logging events.
            This is set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
            The value can be changed by setting the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/>
            property.
            </remarks>
        </member>
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
            <summary>
            the cyclic buffer used to store the logging events
            </summary>
            <remarks>
            The cyclic buffer used to store the logging events.
            The size of the buffer can bse set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
            </remarks>
        </member>
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
            <summary>
            the triggering event evaluator that causes the buffer to be sent immedieatly
            </summary>
            <remarks>
            The object that is used to determine if an event causes the entire
            buffer to be sent immediatly. This field can be <c>null</c>, which
            indicates that event triggering is not to be done. The evaluator
            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to
            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
            </remarks>
        </member>
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
            <summary>
            should the appender overwrite events in the cyclic buffer when it becomes
            full, or should the buffer be flushed when the buffer is full.
            </summary>
            <remarks>
            Set this field using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property. If this field
            is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
            </remarks>
        </member>
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
            <summary>
            Default constructor
            </summary>
            <remarks>
            <para>Empty default constructor</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
            <summary>
            Initialise the appender based on the options set
            </summary>
        </member>
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
            <summary>
            Close this appender instance.
            </summary>
            <remarks>
            <para>Close this appender instance. If this appender is marked
            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in
            the buffer must be sent when the appender is closed.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.spi.LoggingEvent)">
            <summary>
            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/> method.
            </summary>
            <param name="loggingEvent">the event to log</param>
            <remarks>
            <para>Stores the <paramref name="loggingEvent"/> in the cyclic buffer.</para>

            <para>The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.helpers.CyclicBuffer)"/>
            method) if one of the following conditions is met:</para>

            <list type="bullet">
                <item>
                    <description>The cyclic buffer is full and this appender is
                    marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
                </item>
                <item>
                    <description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
                    it is triggered for the <paramref name="loggingEvent"/>
                    specified.</description>
                </item>
            </list>

            <para>Before the event is stored in the buffer it is fixed
            (see <see cref="M:log4net.spi.LoggingEvent.FixVolatileData"/>) to ensure that
            any data referenced by the event will be valid when the buffer
            is processed.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.helpers.CyclicBuffer)">
            <summary>
            Send the contents of the buffer
            </summary>
            <param name="buffer">the buffer containing the events</param>
            <remarks>
            The subclass must override either <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.helpers.CyclicBuffer)"/>
            or <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])"/>.
            </remarks>
        </member>
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])">
            <summary>
            Send the events
            </summary>
            <param name="events">the events</param>
            <remarks>
            The subclass must override either <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.helpers.CyclicBuffer)"/>
            or <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])"/>.
            </remarks>
        </member>
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
            <summary>
            If this appender lossy
            </summary>
            <value>
            true if the appender is lossy
            </value>
            <remarks>
            <para>This appender uses a buffer to store logging events before
            delivering them. A trigering event causes the whole buffer
            to be send to the remote sink. If the buffer overruns before
            a trigerring event then logging events could be lost. Set
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to false (the default) to prevent
            logging events from being lost.</para>

            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to true then an
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
            <summary>
            The buffer size
            </summary>
            <value>
            The buffer size
            </value>
            <remarks>
            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
            representing the maximum number of logging events to collect in a
            cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
            oldest events are deleted as new events are added to the
            buffer. By default the size of the cyclic buffer is 512 events.
            </remarks>
        </member>
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
            <summary>
            The value of the <see cref="T:log4net.spi.ITriggeringEventEvaluator"/> to use
            </summary>
            <value>
            The value of the <see cref="T:log4net.spi.ITriggeringEventEvaluator"/> to use
            </value>
            <remarks>
            <para>This is an optional value and by default it is set to <c>null</c></para>

            <para>The value of the <see cref="T:log4net.spi.ITriggeringEventEvaluator"/> to use.
            The evaluator will be called for each event that is appended
            to this appender. If the evaluator triggers then the current
            buffer will immediatly be sent (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.spi.LoggingEvent[])"/>).</para>

            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.ADONetAppender.m_connection">
            <summary>
            The database connection
            </summary>
            <remarks>
            The database connection
            </remarks>
        </member>
        <member name="F:log4net.Appender.ADONetAppender.m_connectionString">
            <summary>
            Database connection string.
            </summary>
            <remarks>
            Database connection string.
            </remarks>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.#ctor">
            <summary>
            The default constructor does nothing.
            </summary>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.#ctor(log4net.Layout.ILayout)">
            <summary>
            Initialise the appender with a specified layout
            </summary>
            <param name="layout">the layout to use with this appender</param>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.ActivateOptions">
            <summary>
            Initialise the appender based on the options set
            </summary>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.OnClose">
            <summary>
            Override the parent method to close the database
            </summary>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.RequiresLayout">
            <summary>
            The appender requires a <see cref="T:log4net.Layout.ILayout"/>.
            </summary>
            <returns>true</returns>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.SendBuffer(log4net.spi.LoggingEvent[])">
            <summary>
            Write the events to the database
            </summary>
            <param name="events">the events to send</param>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.GetLogStatement(log4net.spi.LoggingEvent)">
            <summary>
            Format the log message into database statement text
            </summary>
            <param name="logEvent">the event being logged</param>
            <returns>text that can be passed to a <see cref="T:System.Data.IDbCommand"/></returns>
            <remarks>
            This method can be overriden by subclasses to provide
            more control over the format of the database statement.
            </remarks>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.InitialiseDatabaseConnection">
            <summary>
            Connects to the database.
            </summary>
        </member>
        <member name="M:log4net.Appender.ADONetAppender.GetConnectionType">
            <summary>
            Retrieves the class type of the ADO.Net provider.
            </summary>
        </member>
        <member name="P:log4net.Appender.ADONetAppender.ConnectionString">
            <summary>
            Database connection string.
            </summary>
            <value>
            Database connection string.
            </value>
            <remarks>
            <para>The connection string determines the .net provider type used.</para>

            <table border="1" CELLPADDING="8">
            <th>Connection String Prefix</th>
            <th>Database Provider</th>

            <tr>
                <td align="center"><b>"Provider="</b></td>
                <td>
                    <para>OLE-DB. <see cref="T:System.Data.OleDb.OleDbConnection"/></para>
                </td>
            </tr>
            <tr>
                <td align="center"><b>"DSN="</b></td>
                <td>
                    <para>ODBC. See <c>Microsoft.Data.Odbc.OdbcConnection</c>.</para>
                    <para>This is an optional package that you can download from
                    <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a>
                    search for <b>ODBC .NET Data Provider</b>.</para>
                </td>
            </tr>
            <tr>
                <td align="center"><b>"Driver="</b></td>
                <td>
                    <para>ODBC. See <c>Microsoft.Data.Odbc.OdbcConnection</c>.</para>
                    <para>This is an optional package that you can download from
                    <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a>
                    search for <b>ODBC .NET Data Provider</b>.</para>
                </td>
            </tr>
            <tr>
                <td align="center"><b>other</b></td>
                <td>
                    <para>SQLClient. <see cref="T:System.Data.SqlClient.SqlConnection"/></para>
                </td>
            </tr>
            </table>

            </remarks>
            <example>Connection string for MS Access via ODBC:
            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\\data\\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\\data\\train33.mdb"</code>
            </example>
            <example>Another connection string for MS Access via ODBC:
            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\\Work\\cvs_root\\log4net-1.2\\access.mdb;UID=;PWD=;"</code>
            </example>
        </member>
        <member name="T:log4net.Appender.ConsoleAppender">
            <summary>
            Appends log events to the console.
            </summary>
            <remarks>
            ConsoleAppender appends log events to <see cref="P:System.Console.Out"/>
            or <see cref="P:System.Console.Error"/>  using a layout specified by the
            user. The default target is <see cref="P:System.Console.Out"/> .
            </remarks>
        </member>
        <member name="T:log4net.Appender.TextWriterAppender">
            <summary>
            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
            </summary>
            <remarks>
            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
            </remarks>
        </member>
        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
            <summary>
            Immediate flush means that the underlying writer or output stream
            will be flushed at the end of each append operation.
            </summary>
            <remarks>
            Immediate
            flush is slower but ensures that each append request is actually
            written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
            <c>false</c>, then there is a good chance that the last few
            logs events are not actually written to persistent media if and
            when the application crashes.

            <para>The <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> variable is set to
            <c>true</c> by default.</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
            <summary>
            This is the <see cref="T:log4net.helpers.QuietTextWriter"/> where we will write to.
            </summary>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.#ctor">
            <summary>
            This default constructor does nothing
            </summary>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
            <summary>
            Instantiate a TextWriterAppender and set the output destination
            to a new <see cref="T:System.IO.StreamWriter"/> initialized with <paramref name="os"/>
            as its <see cref="T:System.IO.Stream"/>.
            </summary>
            <param name="layout">The layout to use with this appender</param>
            <param name="os">The Stream to output to</param>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
            <summary>
            Instantiate a TextWriterAppender and set the output
            destination to <paramref name="writer"/>.
            <para>The <paramref name="writer"/> must have been previously opened by the user.</para>
            </summary>
            <param name="layout">The layout to use with this appender</param>
            <param name="writer">The TextWriter to output to</param>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
            <summary>
            This method determines if there is a sense in attempting to append.

            <para>It checks if there is a set output target and also if
            there is a set layout. If these checks fail, then the boolean
            value <c>false</c> is returned. </para>
            </summary>
            <returns>returns false if any of the preconditions fail</returns>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/>
            method.

            <para>If the output stream exists and is writable then write a log
            statement to the output stream. Otherwise, write a single warning
            message to <see cref="P:System.Console.Error"/>.</para>

            <para>The format of the output will depend on this appender's
            layout.</para>
            </summary>
            <param name="loggingEvent">the event to log</param>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.OnClose">
            <summary>
            Close this appender instance. The underlying stream or writer is also closed.
            <para>Closed appenders cannot be reused</para>
            </summary>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.RequiresLayout">
            <summary>
            The <see cref="T:log4net.Appender.TextWriterAppender"/> requires a layout. Hence, this method returns <c>true</c>.
            </summary>
            <returns>true because this appender requires a layout</returns>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
            <summary>
            Write the footer and close the writer
            </summary>
            <remarks>
            Write the footer and close the writer
            </remarks>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
            <summary>
            Close the underlying <see cref="T:System.IO.TextWriter"/>
            </summary>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.Reset">
            <summary>
            Clear internal references to the writer and other variables.
            Subclasses can override this method for an alternate closing behavior.
            </summary>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
            <summary>
            Write a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> method.
            </summary>
        </member>
        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
            <summary>
            Write a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> method.
            </summary>
        </member>
        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
            <summary>
            The <see cref="T:log4net.spi.IErrorHandler"/> for this Appender and also the underlying <see cref="T:log4net.helpers.QuietTextWriter"/> if any.
            </summary>
        </member>
        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
            <summary>
            If the <b>ImmediateFlush</b> option is set to
            <c>true</c>, the appender will flush at the end of each
            write.
            </summary>
            <remarks>
            This is the default behavior. If the option is set to
            <c>false</c>, then the underlying stream can defer writing
            to physical medium to a later time.

            <para>Avoiding the flush operation at the end of each append results in
            a performance gain of 10 to 20 percent. However, there is safety
            tradeoff involved in skipping flushing. Indeed, when flushing is
            skipped, then it is likely that the last few log events will not
            be recorded on disk when the application exits. This is a high
            price to pay even for a 20% performance gain.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.TextWriterAppender.Writer">
            <summary>
            <para>Sets the Writer where the log output will go. The
            specified Writer must be opened by the user and be
            writable.</para>

            <para>The <see cref="T:System.IO.TextWriter"/> will be closed when the
            appender instance is closed.</para>

            <para><b>WARNING:</b> Logging to an unopened Writer will fail.</para>
            </summary>
        </member>
        <member name="F:log4net.Appender.ConsoleAppender.CONSOLE_OUT">
            <summary>
            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writting to the Console standard out
            </summary>
        </member>
        <member name="F:log4net.Appender.ConsoleAppender.CONSOLE_ERR">
            <summary>
            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writting to the Console standard error
            </summary>
        </member>
        <member name="F:log4net.Appender.ConsoleAppender.m_target">
            <summary>
            The target that is being used by the appender
            </summary>
        </member>
        <member name="M:log4net.Appender.ConsoleAppender.#ctor">
            <summary>
            The default constructor does nothing.
            </summary>
        </member>
        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">
            <summary>
            Initialise the appender with a specified layout
            </summary>
            <param name="layout">the layout to use with this appender</param>
        </member>
        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.String)">
            <summary>
            Initialise the appender with a specified layout and
            console output stream.
            The console output stream must be <c>"Console.Out"</c>
            or <c>"Console.Error"</c>
            </summary>
            <param name="layout">the layout object to use</param>
            <param name="target">the console output stream</param>
        </member>
        <member name="M:log4net.Appender.ConsoleAppender.TargetWarn(System.String)">
            <summary>
            Internal method called to indicate an error with
            the console stream name provided.
            </summary>
            <param name="value">the erroneous console stream name</param>
        </member>
        <member name="M:log4net.Appender.ConsoleAppender.ActivateOptions">
            <summary>
            Initialise the appender based on the options set
            </summary>
        </member>
        <member name="M:log4net.Appender.ConsoleAppender.CloseWriter">
            <summary>
            Override the parent method to do nothing.
            </summary>
        </member>
        <member name="P:log4net.Appender.ConsoleAppender.Target">
            <summary>
            Target is the value of the console output stream.
            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.
            </summary>
        </member>
        <member name="T:log4net.Appender.CountingAppender">
            <summary>
            Implements an Appender for test purposes that counts the
            number of output calls to Append
            </summary>
            <remarks>
            <para>Implements an Appender for test purposes that counts the
            number of output calls to Append.</para>

            <para>This appender is usind in the unit tests</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.CountingAppender.m_counter">
            <summary>
            Counts the number of times DoAppend has been called
            </summary>
        </member>
        <member name="M:log4net.Appender.CountingAppender.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:log4net.Appender.CountingAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            Registers how many times the method has been called
            </summary>
            <param name="logEvent"></param>
        </member>
        <member name="M:log4net.Appender.CountingAppender.RequiresLayout">
            <summary>
            This class doesn't have it's own layout object
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.Appender.CountingAppender.Counter">
            <summary>
            Returns the number of times DoAppend has been called
            </summary>
        </member>
        <member name="T:log4net.Appender.EventLogAppender">
            <summary>
            EventLogAppender writes events to the system
            event log.
            </summary>
            <remarks>
            TThe string is
            then passed to the system event log.
            </remarks>
        </member>
        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.spi.Level)">
            <summary>
            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.spi.Level"/> <paramref name="p"/>
            </summary>
            <param name="level">the Level to convert to an EventLogEntryType</param>
            <returns>The eqivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.spi.Level"/> <paramref name="p"/></returns>
            <remarks>
            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>
            values to use in logging levels than there are in the
            <see cref="T:log4net.spi.Level"/> this is a one way mapping. There is
            a loss of information during the conversion.
            </remarks>
        </member>
        <member name="F:log4net.Appender.EventLogAppender.m_logName">
            <summary>
            The log name is the section in the event logs where the messages
            are stored.
            </summary>
        </member>
        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">
            <summary>
            Name of the application to use when logging.  This appears in the
            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.
            </summary>
        </member>
        <member name="F:log4net.Appender.EventLogAppender.m_machineName">
            <summary>
            The name of the machine which holds the event log. This is
            currently only allowed to be '.' i.e. the current machine.
            </summary>
        </member>
        <member name="M:log4net.Appender.EventLogAppender.#ctor">
            <summary>
            The default constructor does nothing.
            </summary>
        </member>
        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">
            <summary>
            Initialise the appender with a specified layout
            </summary>
            <param name="layout">the layout to use with this appender</param>
        </member>
        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">
            <summary>
            Initialise the appender based on the options set
            </summary>
        </member>
        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/>
            method.
            </summary>
            <param name="loggingEvent">the event to log</param>
        </member>
        <member name="M:log4net.Appender.EventLogAppender.RequiresLayout">
            <summary>
            The appender requires a <see cref="T:log4net.Layout.ILayout"/>.
            </summary>
            <returns>true</returns>
        </member>
        <member name="P:log4net.Appender.EventLogAppender.LogName">
            <summary>
            The name of the log where messages will be stored.
            </summary>
            <value>
            The string name of the log where messages will be stored.
            </value>
            <remarks>
            <para>This is the name of the log as it appears in the Event Viewer
            tree. The default value is to log into the <c>Application</c>
            log, this is where most applications write their events. However
            if you need a seperate log for your application (or applications)
            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>
            <para>This should not be used to distinguish your event log messages
            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>
            property should be used to distinguish events. This property should be
            used to group together events into a single log.
            </para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">
            <summary>
            Property used to set the Application name.  This appears in the
            event logs when logging.
            </summary>
            <value>
            The string used to distinguish events from different sources.
            </value>
            <remarks>
            Sets the event log source property.
            </remarks>
        </member>
        <member name="P:log4net.Appender.EventLogAppender.MachineName">
            <summary>
            This property is used to return the name of the computer to use
            when accessing the event logs.  Currently, this is the current
            computer, denoted by a dot "."
            </summary>
            <value>
            The string name of the machine holding the event log that
            will be logged into.
            </value>
            <remarks>
            This property cannot be changed. It is currently set to '.'
            i.e. the local machine. This may be changed in future.
            </remarks>
        </member>
        <member name="T:log4net.Appender.FileAppender">
            <summary>
            FileAppender appends log events to a file.
            </summary>
            <remarks>
            Logging events are sent to the file specified.
            The file can be opened in either append or
            overwite modes.
            </remarks>
        </member>
        <member name="F:log4net.Appender.FileAppender.m_appendToFile">
            <summary>
            Flag to indicate if we should append to the file
            or overwite the file. The default is to append
            </summary>
        </member>
        <member name="F:log4net.Appender.FileAppender.m_fileName">
            <summary>
            The name of the log file.
            </summary>
        </member>
        <member name="M:log4net.Appender.FileAppender.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">
            <summary>
            Construct a new appender using the layout, file and append mode.
            </summary>
            <param name="layout">the layout to use with this appender</param>
            <param name="filename">the full path to the file to write to</param>
            <param name="append">flag to indicate if the file should be appended to</param>
        </member>
        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">
            <summary>
            Construct a new appender using the layout and file specified.
            The file will be appended to.
            </summary>
            <param name="layout">the layout to use with this appender</param>
            <param name="filename">the full path to the file to write to</param>
        </member>
        <member name="M:log4net.Appender.FileAppender.ActivateOptions">
            <summary>
            Activate the options on the file appender. This will
            case the file to be opened.
            </summary>
        </member>
        <member name="M:log4net.Appender.FileAppender.Reset">
            <summary>
            Close any previously opened file and call the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>
            </summary>
        </member>
        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">
            <summary>
            Convert a path into a fully qualified path
            </summary>
            <param name="path">the path to convert</param>
            <returns>the fully qualified path</returns>
            <remarks>
            <para>Converts the path specified to a fully
            qualified path. If the path is relative it is
            taken as relative from the <see cref="P:System.AppDomain.BaseDirectory"/>
            path.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.FileAppender.CloseFile">
            <summary>
            Closes the previously opened file.
            </summary>
        </member>
        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">
            <summary>
            Sets and <i>opens</i> the file where the log output will
            go. The specified file must be writable.
            </summary>
            <param name="fileName">The path to the log file</param>
            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>
            <remarks>
            <para>If there was already an opened file, then the previous file
            is closed first.</para>

            <para>This method will ensure that the directory structure
            for the <paramref name="fileName"/> specified exists.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">
            <summary>
            Sets the quiet writer being used.
            </summary>
            <remarks>
            This method can be overriden by sub classes.
            </remarks>
            <param name="writer">the writer to set</param>
        </member>
        <member name="P:log4net.Appender.FileAppender.File">
            <summary>
            <see cref="P:log4net.Appender.FileAppender.File"/> is the path to the file that logging will be written to
            </summary>
            <value>
            <see cref="P:log4net.Appender.FileAppender.File"/> is the path to the file that logging will be written to
            </value>
            <remarks>
            <para><see cref="P:log4net.Appender.FileAppender.File"/> is the path to the file that logging
            will be written to.</para>

            <para>If the path is relative it is taken as relative from
            the <see cref="P:System.AppDomain.BaseDirectory"/> path.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.FileAppender.AppendToFile">
            <summary>
            AppendToFile is a flag that indicates weather the file should be
            appended to or overwitten. If the value is set to false then the
            file will be overwitten. If it is set to true then the file will
            be appended to. The default value is true.
            </summary>
        </member>
        <member name="T:log4net.Appender.MemoryAppender">
            <summary>
            MemoryAppender stores logging events in an array
            </summary>
            <remarks>
            <para>The memory appender stores all the <see cref="T:log4net.spi.LoggingEvent"/>
            that are appended in an in-memory array.</para>

            <para>Use the <see cref="P:log4net.Appender.MemoryAppender.Events"/> property to get
            the current list of events that have been appended.
            Use the <see cref="M:log4net.Appender.MemoryAppender.Clear"/> method to clear the
            current list of events.</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
            <summary>
            The list of events that have been appended
            </summary>
            <remarks>
            The list of events that have been appended
            </remarks>
        </member>
        <member name="M:log4net.Appender.MemoryAppender.#ctor">
            <summary>
            Default constructor
            </summary>
            <remarks>
            <para>Empty default constructor</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.MemoryAppender.Clear">
            <summary>
            Clear the list of events
            </summary>
            <remarks>
            Clear the list of events
            </remarks>
        </member>
        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/> method.
            </summary>
            <param name="loggingEvent">the event to log</param>
            <remarks>
            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.MemoryAppender.Events">
            <summary>
            Get the events that have been logged
            </summary>
            <value>
            Get the events that have been logged
            </value>
            <remarks>
            Get the events that have been logged
            </remarks>
        </member>
        <member name="T:log4net.Appender.OutputDebugStringAppender">
            <summary>
            Appends log events to the OutputDebugString system.
            </summary>
            <remarks>
            <para>OutputDebugStringAppender appends log events to the
            OutputDebugString system.</para>

            <para>The string is passed to the <c>OutputDebugString</c> method
            (exported from Kernel32.dll).</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">
            <summary>
            The default constructor does nothing.
            </summary>
        </member>
        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor(log4net.Layout.ILayout)">
            <summary>
            Initialise the appender with a specified layout
            </summary>
            <param name="layout">the layout to use with this appender</param>
        </member>
        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.spi.LoggingEvent)"/>
            method.
            </summary>
            <param name="loggingEvent">the event to log</param>
        </member>
        <member name="M:log4net.Appender.OutputDebugStringAppender.RequiresLayout">
            <summary>
            The appender requires a <see cref="T:log4net.Layout.ILayout"/>.
            </summary>
            <returns>true</returns>
        </member>
        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">
            <summary>
            Stub for OutputDebugString native mathod
            </summary>
            <param name="lpOutputString">the string to output</param>
        </member>
        <member name="T:log4net.Appender.IRemoteLoggingSink">
            <summary>
            Interface used to deliver <see cref="T:log4net.spi.LoggingEvent"/> objects to a remote sink
            </summary>
            <remarks>
            This interface must be implemented by a remoting sink
            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used
            to deliver logging events to the sink.
            </remarks>
        </member>
        <member name="M:log4net.Appender.IRemoteLoggingSink.LogEvents(log4net.spi.LoggingEvent[])">
            <summary>
            Deliver see cref="LoggingEvent"/> objects to the remote sink
            </summary>
            <param name="logEvents">array of events to log</param>
        </member>
        <member name="T:log4net.Appender.RemotingAppender">
            <summary>
            Appender that delivers logging events to a remote logging sink.
            See <see cref="T:log4net.Appender.IRemoteLoggingSink"/>
            </summary>
            <remarks>
            This Appender is designed to deliver events to a remote sink.
            That is any object that implements the <see cref="T:log4net.Appender.IRemoteLoggingSink"/>
            interface. It delivers the events using .NET remoting. The
            object to deliver events to is specified by setting the
            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.
            </remarks>
        </member>
        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">
            <summary>
            The URL of the remote sink
            </summary>
        </member>
        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">
            <summary>
            The local proxy (.NET remoting) for the remote logging sink
            </summary>
        </member>
        <member name="M:log4net.Appender.RemotingAppender.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">
            <summary>
            Initialise the appender based on the options set
            </summary>
        </member>
        <member name="M:log4net.Appender.RemotingAppender.RequiresLayout">
            <summary>
            The <see cref="T:log4net.Appender.RemotingAppender"/> does not require a layout. Hence, this method returns <c>false</c>.
            </summary>
            <returns>false because this appender does not layout the logging events</returns>
        </member>
        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.spi.LoggingEvent[])">
            <summary>
            Send the contents of the buffer to the remote sink
            </summary>
            <param name="events">the events to send</param>
        </member>
        <member name="P:log4net.Appender.RemotingAppender.Sink">
            <summary>
            The URL of the well-known object that will accept the logging events
            </summary>
            <value>
            A string that is the well-knonw URL of the remote sink.
            </value>
        </member>
        <member name="T:log4net.Appender.IDateTime">
            <summary>
            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
            </summary>
            <remarks>
            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.
            Used primarily to allow test classes to plug themselves in so they can
            supply test date/times.
            </remarks>
        </member>
        <member name="P:log4net.Appender.IDateTime.Now">
            <summary>
            This property will return the 'current' time.
            </summary>
        </member>
        <member name="T:log4net.Appender.RollingFileAppender">
            <summary>
            Appender that rolls log files based on size or date or both
            </summary>
            <remarks>
            <para>RollingFileAppender can function as either or and do both
            at the same time (making size based rolling files until a data/time
            boundary is crossed at which time it rolls all of those files
            based on the setting for <see cref="F:log4net.Appender.RollingFileAppender.m_rollingStyle"/>.</para>

            <para>
            A of few additional optional features have been added:<br/>
            -- Attach date pattern for current log file <see cref="F:log4net.Appender.RollingFileAppender.m_staticLogFileName"/><br/>
            -- Backup number increments for newer files <see cref="F:log4net.Appender.RollingFileAppender.m_countDirection"/><br/>
            -- Infinite number of backups by file size <see cref="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups"/>
            </para>
            <para>A few notes and warnings:  For large or infinite number of backups
            countDirection > 0 is highly recommended, with staticLogFileName = false if
            time based rolling is also used -- this will reduce the number of file renamings
            to few or none.  Changing staticLogFileName or countDirection without clearing
            the directory could have nasty side effects.  If Date/Time based rolling
            is enabled, CompositeRollingAppender will attempt to roll existing files
            in the directory without a date/time tag based on the last modified date
            of the base log files last modification.</para>
            <para>A maximum number of backups based on date/time boundries would be nice
            but is not yet implemented.</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">
            <summary>
            This object supplies the current date/time.  Allows test code to plug in
            a method to control this class when testing date/time based rolling.
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">
            <summary>
            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> meaning daily rollover.
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">
            <summary>
            The actual formatted filename that is currently being written to
            or will be the file transferred to on roll over
            (based on staticLogFileName).
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">
            <summary>
            The timestamp when we shall next recompute the filename.
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_now">
            <summary>
            Holds date of last roll over
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">
            <summary>
            The type of rolling done
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">
            <summary>
            The default maximum file size is 10MB
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">
            <summary>
            There is zero backup files by default
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">
            <summary>
            How many sized based backups have been made so far
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_maxTimeRollBackups">
            <summary>
            not yet implemented
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">
            <summary>
            By default newer files have lower numbers
            </summary>
            <remarks>
            By default newer files have lower numbers. (countDirection < 0)
            ie. log.1 is most recent, log.5 is the 5th backup, etc...
            countDirection > 0 does the opposite ie.
            log.1 is the first backup made, log.5 is the 5th backup made, etc.
            For infinite backups use countDirection > 0 to reduce rollOver costs.
            </remarks>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">
            <summary>
            The rolling mode used in this appender
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">
            <summary>
            Cache flag set if we are rolling by date
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">
            <summary>
            Cache flag set if we are rolling by size
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">
            <summary>
            Flag to indicate if we always log to the same file
            </summary>
            <remarks>
            By default file.log is always the current file.  Optionally
            file.log.yyyy-mm-dd for current formated datePattern can by the currently
            logging file (or file.log.curSizeRollBackup or even
            file.log.yyyy-mm-dd.curSizeRollBackup) This will make time based roll
            overs with a large number of backups much faster -- it won't have to
            rename all the backups!
            </remarks>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">
            <summary>
            FileName provided in configuration.  Used for rolling properly
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.#ctor">
            <summary>
            The default constructor does nothing
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">
            <summary>
            Sets the quiet writer being used.
            </summary>
            <remarks>
            This method can be overriden by sub classes.
            </remarks>
            <param name="writer">the writer to set</param>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            Handles append time behavior for CompositeRollingAppender.  This checks
            if a roll over either by date (checked first) or time (checked second)
            is need and then appends to the file last.
            </summary>
            <param name="loggingEvent"></param>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">
            <summary>
            Creates and opens the file for logging.  If <see cref="F:log4net.Appender.RollingFileAppender.m_staticLogFileName"/>
            is false then the fully qualified name is determined and used.
            </summary>
            <param name="fileName">the name of the file to open</param>
            <param name="append">true to append to existing file</param>
            <remarks>
            <para>This method will ensure that the directory structure
            for the <paramref name="fileName"/> specified exists.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.DetemineCurSizeRollBackups">
            <summary>
            Determines curSizeRollBackups (only within the current rollpoint)
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">
            <summary>
            Generates a wildcard pattern that can be used to find all files
            that are similar to the base file name.
            </summary>
            <param name="baseFileName"></param>
            <returns></returns>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">
            <summary>
            Builds a list of filenames for all files matching the base filename plus a file
            pattern.
            </summary>
            <param name="baseFilePath"></param>
            <returns></returns>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">
            <summary>
            Initiates a roll over if needed for crossing a date boundary since the last run.
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">
            <summary>
            <para>Initializes based on exisiting conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.
            The following is done:</para>
                A) determine curSizeRollBackups (only within the current rollpoint)
                B) initiates a roll over if needed for crossing a date boundary since the last run.
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">
            <summary>
            Does the work of bumping the 'current' file counter higher
            to the highest count when an incremental file name is seen.
            The highest count is either the first file (when count direction
            is greater than 0 ) or the last file (when count direction less than 0).
            In either case, we want to know the highest count that is present.
            </summary>
            <param name="baseFile"></param>
            <param name="curFileName"></param>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">
            <summary>
            Takes a list of files and a base file name, and looks for
            'incremented' versions of the base file.  Bumps the max
            count up to the highest count seen.
            </summary>
            <param name="baseFile"></param>
            <param name="arrayFiles"></param>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod">
            <summary>
            Calculates the RollPoint for the m_datePattern supplied.
            </summary>
            <returns>The RollPoint that is most acurate for the date pattern supplied</returns>
            <remarks>
            Essentially the date pattern is examined to determine what the
            most sutable roll point is. The roll point chosen is the roll point
            with the smallest period that can be detected using the date pattern
            supplied. i.e. if the date pattern only outputs the year, month, day
            and hour then the smallest roll point that can be detected whould be
            and hourly roll point as minutes could not be detected.
            </remarks>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">
            <summary>
            Sets initial conditions including date/time roll over information, first check,
            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize
            the current number of backups.
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime">
            <summary>
            Rollover the file(s) to date/time tagged file(s).
            Opens the new file (through setFile) and resets curSizeRollBackups.
            </summary>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">
            <summary>
            Renames file <paramref name="from"/> to file <paramref name="to"/>.  It
            also checks for existence of target file and deletes if it does.
            </summary>
            <param name="from"></param>
            <param name="to"></param>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">
            <summary>
            Delete's the specified file if it exists
            </summary>
            <param name="fileName">the file name to delete</param>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">
            <summary>
            Implements roll overs base on file size.
            </summary>
            <remarks>
            <para>If the maximum number of size based backups is reached
            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest
            file is deleted -- it's index determined by the sign of countDirection.
            If <c>countDirection</c> < 0, then files
            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}
            are renamed to {<c>File.2</c>, ...,
            <c>File.curSizeRollBackups</c>}.     Moreover, <c>File</c> is
            renamed <c>File.1</c> and closed.</para>

            A new file is created to receive further log output.

            <para>If <c>maxSizeRollBackups</c> is equal to zero, then the
            <c>File</c> is truncated with no backup files created.</para>

            <para>If <c>maxSizeRollBackups</c> < 0, then <c>File</c> is
            renamed if needed and no files are deleted.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime)">
            <summary>
            Roll on to the next interval after the date passed
            </summary>
            <param name="currentDateTime">the current date</param>
            <returns>the next roll point an interval after the currentDateTime date</returns>
            <remarks>
            Advances the date to the next roll point after the
            currentDateTime date passed to the method.
            </remarks>
        </member>
        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">
            <summary>
            Roll on to the next interval after the date passed
            </summary>
            <param name="currentDateTime">the current date</param>
            <param name="rollPoint">the type of roll point we are working with</param>
            <returns>the next roll point an interval after the currentDateTime date</returns>
            <remarks>
            Advances the date to the next roll point after the
            currentDateTime date passed to the method.
            </remarks>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.Now">
            <summary>
            This property will return the 'current' time.
            </summary>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">
            <summary>
            The <b>DatePattern</b> takes a string in the same format as
            expected by <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.
            This options determines the rollover schedule.
            </summary>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">
            <summary>
            Returns the value of the <b>maxSizeRollBackups</b> option.
            </summary>
            <remarks>
            <para>The <b>MaxSizeRollBackups</b> option determines how many backup
            files are kept before the oldest is erased. This option takes
            an integer value. If set to zero, then there will be no
            backup files and the log file will be truncated when it reaches
            <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  If a negative number is supplied then
            no deletions will be made.  Note that this could result in
            very slow performance as a large number of files are rolled over unless
            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> up is used.</para>

            <para>The maximum applys to <b>each</b> time based group of files and <b>not</b> the total.
            Using a daily roll the maximum total files would be <c>(#days run) * (maxSizeRollBackups)</c>
            </para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">
            <summary>
            Get the maximum size that the output file is allowed to reach
            before being rolled over to backup files.
            <para>This method is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except
            that it is required for differentiating the setter taking a
            <see cref="T:System.Int64"/> argument from the setter taking a
            <see cref="T:System.String"/> argument.</para>
            </summary>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">
            <summary>
            Set the maximum size that the output file is allowed to reach
            before being rolled over to backup files.

            <para>In configuration files, the <b>MaxFileSize</b> option takes an
            long integer in the range 0 - 2^63. You can specify the value
            with the suffixes "KB", "MB" or "GB" so that the integer is
            interpreted being expressed respectively in kilobytes, megabytes
            or gigabytes. For example, the value "10KB" will be interpreted
            as 10240.</para>
            </summary>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.File">
            <summary>
            <see cref="P:log4net.Appender.RollingFileAppender.File"/> is the path to the file that logging will be written to
            </summary>
            <value>
            <see cref="P:log4net.Appender.RollingFileAppender.File"/> is the path to the file that logging will be written to
            </value>
            <remarks>
            <para><see cref="P:log4net.Appender.RollingFileAppender.File"/> is the path to the file that logging
            will be written to.</para>

            <para>If the path is relative it is taken as relative from
            the <see cref="P:System.AppDomain.BaseDirectory"/> path.</para>
            </remarks>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">
            <summary>
            Number rolling file count direction. Either positive or negative.
            Indicates if the current file is the lowest numberd file or the
            highest numbered file.
            </summary>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">
            <summary>
            Set the rolling style
            </summary>
        </member>
        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">
            <summary>
            Set the m_staticLogFileName flag
            </summary>
        </member>
        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">
            <summary>
            The code assumes that the following 'time' constants are in a increasing sequence.
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TOP_OF_TROUBLE">
            <summary>
            Roll the log not based on the date
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TOP_OF_MINUTE">
            <summary>
            Roll the log for each minute
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TOP_OF_HOUR">
            <summary>
            Roll the log for each hour
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HALF_DAY">
            <summary>
            Roll the log twice a day (midday and midnight)
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TOP_OF_DAY">
            <summary>
            Roll the log each day (midnight)
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TOP_OF_WEEK">
            <summary>
            Roll the log each week
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TOP_OF_MONTH">
            <summary>
            Roll the log each month
            </summary>
        </member>
        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">
            <summary>
            Style of rolling to use
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">
            <summary>
            Roll files based only on the size of the file
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">
            <summary>
            Roll files based only on the date
            </summary>
        </member>
        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">
            <summary>
            Roll files based on both the size and date of the file
            </summary>
        </member>
        <member name="T:log4net.Appender.SMTPAppender">
            <summary>
            Send an e-mail when a specific logging event occurs, typically on errors or fatal errors.
            </summary>
            <remarks>
            The number of logging events delivered in this e-mail depend on
            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The
            <see cref="T:log4net.Appender.SMTPAppender"/> keeps only the last
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its cyclic buffer. This
            keeps memory requirements at a reasonable level while still
            delivering useful application context.
            </remarks>
        </member>
        <member name="M:log4net.Appender.SMTPAppender.#ctor">
            <summary>
            </summary>
        </member>
        <member name="M:log4net.Appender.SMTPAppender.SendBuffer(log4net.spi.LoggingEvent[])">
            <summary>
            Send the contents of the cyclic buffer as an e-mail message.
            </summary>
            <param name="events">the events to send</param>
        </member>
        <member name="M:log4net.Appender.SMTPAppender.RequiresLayout">
            <summary>
            The <see cref="T:log4net.Appender.SMTPAppender"/> requires a <see cref="T:log4net.Layout.ILayout"/>.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.Appender.SMTPAppender.To">
            <summary>
            Returns value of the <b>To</b> option.
            </summary>
        </member>
        <member name="P:log4net.Appender.SMTPAppender.From">
            <summary>
            Returns value of the <b>From</b> option.
            </summary>
        </member>
        <member name="P:log4net.Appender.SMTPAppender.Subject">
            <summary>
            Returns value of the <b>Subject</b> option.
            </summary>
        </member>
        <member name="P:log4net.Appender.SMTPAppender.SMTPHost">
            <summary>
            The <b>SMTPHost</b> option takes a string value which should be a
            the host name of the SMTP server that will send the e-mail message.
            </summary>
        </member>
        <member name="P:log4net.Appender.SMTPAppender.LocationInfo">
            <summary>
            Set to true to include location information
            </summary>
            <remarks>
            <para>The <b>LocationInfo</b> option takes a boolean value. By
            default, it is set to false which means there will be no effort
            to extract the location information related to the event. As a
            result, the layout that formats the events as they are sent out
            in an e-mail is likely to place the wrong location information
            (if present in the format).</para>

            <para>Location information extraction is comparatively very slow and
            should be avoided unless performance is not a concern.</para>
            </remarks>
        </member>
        <member name="T:log4net.Appender.TraceAppender">
            <summary>
            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.
            </summary>
            <remarks>
            <para>TraceAppender appends log events to the
            Trace system.  The <i>.config</i> file can be used
            to control what listeners are actually used.</para>

            <para>The string is
            then passed to the <see cref="M:System.Diagnostics.Trace.Write(System.String)"/> method.</para>
            </remarks>
        </member>
        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">
            <summary>
            Immediate flush means that the underlying writer or output stream
            will be flushed at the end of each append operation.
            </summary>
            <remarks>
            Immediate
            flush is slower but ensures that each append request is actually
            written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to
            <c>false</c>, then there is a good chance that the last few
            logs events are not actually written to persistent media if and
            when the application crashes.

            <para>The <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> variable is set to
            <c>true</c> by default.</para>
            </remarks>
        </member>
        <member name="M:log4net.Appender.TraceAppender.#ctor">
            <summary>
            The default constructor does nothing.
            </summary>
        </member>
        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">
            <summary>
            Initialise the appender with a specified layout
            </summary>
            <param name="layout">the layout to use with this appender</param>
        </member>
        <member name="M:log4net.Appender.TraceAppender.OnClose">
            <summary>
            Override the parent method to close the default trace channel
            </summary>
        </member>
        <member name="M:log4net.Appender.TraceAppender.Append(log4net.spi.LoggingEvent)">
            <summary>
            Actual writing occurs here.
            <para>Most subclasses of <see cref="T:log4net.Appender.TextWriterAppender"/> will need to
            override this method.</para>
            </summary>
            <param name="loggingEvent">the event to log</param>
        </member>
        <member name="M:log4net.Appender.TraceAppender.RequiresLayout">
            <summary>
            The appender requires a <see cref="T:log4net.Layout.ILayout"/>.
            </summary>
            <returns>true</returns>
        </member>
        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">
            <summary>
            If the <b>ImmediateFlush</b> option is set to
            <c>true</c>, the appender will flush at the end of each
            write.
            </summary>
            <remarks>
            This is the default behavior. If the option is set to
            <c>false</c>, then the underlying stream can defer writing
            to physical medium to a later time.

            <para>Avoiding the flush operation at the end of each append results in
            a performance gain of 10 to 20 percent. However, there is safety
            tradeoff involved in skipping flushing. Indeed, when flushing is
            skipped, then it is likely that the last few log events will not
            be recorded on disk when the application exits. This is a high
            price to pay even for a 20% performance gain.</para>
            </remarks>
        </member>
        <member name="T:log4net.Config.BasicConfigurator">
            <summary>
            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
            </summary>
            <remarks>
            Allows very simple programatic configuration of log4net.
            </remarks>
        </member>
        <member name="M:log4net.Config.BasicConfigurator.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Config.BasicConfigurator.Configure">
            <summary>
            Initialise the log4net system with a default configuration.
            </summary>
            <remarks>
            <para>Initialises the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
            that will write to <c>Console.Out</c>. The log messages are
            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
            using the <see cref="F:log4net.Layout.PatternLayout.TTCC_CONVERSION_PATTERN"/>
            layout style.</para>
            </remarks>
        </member>
        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">
            <summary>
            Initialise the log4net system using the specified appender
            </summary>
            <param name="appender">the appender to use to log all logging events</param>
        </member>
        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">
            <summary>
            Initialise the log4net system with a default configuration.
            </summary>
            <param name="repository">the repository to configure</param>
            <remarks>
            <para>Initialises the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>
            that will write to <c>Console.Out</c>. The log messages are
            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object
            using the <see cref="F:log4net.Layout.PatternLayout.TTCC_CONVERSION_PATTERN"/>
            layout style.</para>
            </remarks>
        </member>
        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">
            <summary>
            Initialise the log4net system using the specified appender
            </summary>
            <param name="repository">the repository to configure</param>
            <param name="appender">the appender to use to log all logging events</param>
        </member>
        <member name="T:log4net.Config.ConfiguratorAttribute">
            <summary>
            Base class for all ConfiguratorAttributes
            </summary>
            <remarks>
            This is an abstract class that must be extended by
            specific configurators. This attribute allows the
            configurator to be parametarised by an assembly level
            attribute.
            </remarks>
        </member>
        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
            <summary>
            Configure the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
            </summary>
            <param name="assembly">The assembly that this attribute was defined on</param>
            <param name="repository">The repository to configure</param>
        </member>
        <member name="T:log4net.Config.DomainAttribute">
            <summary>
            Assembly level attribute that specifes the logging domain for the assembly
            </summary>
            <remarks>
            <para>Assemblies are mapped to logging domains. Each domain has its own
            logging repository. This attribute specified on the assembly controls
            the configuration of the domain. The <see cref="P:log4net.Config.DomainAttribute.Name"/> property specifies the name
            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.DomainAttribute.RepositoryType"/>
            specifies the type of the repository objects to create for the domain. The
            <see cref="P:log4net.Config.DomainAttribute.UseExecutableDomain"/> flag can be specified to force this assembly to use
            the domain of the executable.</para>

            <para>This attribute can only be specified on the assembly and may only be used
            once per assembly.</para>
            </remarks>
        </member>
        <member name="P:log4net.Config.DomainAttribute.Name">
            <summary>
            The name of the logging domain
            </summary>
            <value>
            The string name to use as the name of the domain associated with this
            assembly
            </value>
            <remarks>
            This value does not have to be unique. Several assemblies can share the
            same domain. They will share the logging configuration of the domain.
            </remarks>
        </member>
        <member name="P:log4net.Config.DomainAttribute.RepositoryType">
            <summary>
            The type of repository to create for this assembly
            </summary>
            <value>
            The type of repository to create for this assembly
            </value>
            <remarks>
            <para>The type of the repository to create for the domain.
            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>
            interface.</para>

            <para>This will be the type of repository created when
            the domain is created. If multiple assemblies reference the
            same domain then the repository is only created once using the
            <c>RepositoryType</c> of the first assembly to call into the
            domain.</para>
            </remarks>
        </member>
        <member name="P:log4net.Config.DomainAttribute.UseExecutableDomain">
            <summary>
            Use the executable's domain not a seperate domain for this assembly
            </summary>
            <value>
            Use the executable's domain not a seperate domain for this assembly
            </value>
            <remarks>
            Set this property to true to use the domain of the executable rather than
            a seperate domain for this assembly. The domain used is the domain
            for the <see cref="M:System.Reflection.Assembly.GetEntryAssembly"/>
            assembly in the current <see cref="T:System.AppDomain"/>.
            </remarks>
        </member>
        <member name="P:log4net.Config.DomainAttribute.UseDefaultDomain">
            <summary>
            Use the default domain for this AppDomain
            </summary>
            <value>
            Use the default domain for this AppDomain
            </value>
            <remarks>
            <para>Set this property to true to use the default domain
            rather than a seperate domain for this assembly. The domain
            used is shared between all the assemblies that specify the
            <see cref="P:log4net.Config.DomainAttribute.UseDefaultDomain"/> attribute within the current
            <see cref="T:System.AppDomain"/>.</para>
            </remarks>
        </member>
        <member name="T:log4net.Config.DOMConfigurator">
            <summary>
            Use this class to initialize the log4net environment using a DOM tree.
            </summary>
            <remarks>
            Configure a <see cref="T:log4net.Repository.ILoggerRepository"/> using an XML DOM tree.
            </remarks>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.#ctor">
            <summary>
            No argument constructor.
            </summary>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.Configure">
            <summary>
            Automaticaly configure the log4net system based on the
            application's configuration settings.
            </summary>
            <remarks>
            Each application has a configuration file. This has the
            same name as the application with '.config' appended.
            This file is XML and calling this function prompts the
            configurator to look in that file for a section called
            <c>log4net</c> that contains the configuration data.
            Replace but not override the Configure() method on
            BasicConfigurator.
            </remarks>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">
            <summary>
            Automaticaly configure the log4net system based on the
            application's configuration settings.
            </summary>
            <remarks>
            Each application has a configuration file. This has the
            same name as the application with '.config' appended.
            This file is XML and calling this function prompts the
            configurator to look in that file for a section called
            <c>log4net</c> that contains the configuration data.
            Replace but not override the Configure() method on
            BasicConfigurator.
            </remarks>
            <param name="repository">the repository to configure</param>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">
            <summary>
            Configure log4net using a <c>log4net</c> element
            </summary>
            <remarks>
            Load the log4net configuration from the XML element
            supplied as <paramref name="element"/>.
            </remarks>
            <param name="element">the element to parse</param>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
            <summary>
            Configure log4net using a <c>log4net</c> element
            </summary>
            <remarks>
            Load the log4net configuration from the XML element
            supplied as <paramref name="element"/>.
            </remarks>
            <param name="repository">the repository to configure</param>
            <param name="element">the element to parse</param>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">
            <summary>
            Configure log4net using the config file specified.
            </summary>
            <param name="configFile">the XML config file to load
            the configuration from</param>
            <remarks>
            The configuration file must be valid XML. It must contain
            at least one element called <c>log4net</c> that holds
            the configuration data.
            <para>
            The logging file could be specified in the applications
            configuration file (either <c>MyAppName.exe.config</c> for a
            normal application on <c>Web.config</c> for an ASP.NET application).
            To Load the configuration use code like:
            </para>
            <code>
            using log4net.Config;
            using System.IO;
            using System.Configuration;

            ...

            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
            </code>
            <para>In your <c>.config</c> file you must specify the config file to
            use like this:</para>
            <code>
            <configuration>
                <appSettings>
                    <add key="log4net-config-file" value="log.config"/>
                </appSettings>
            </configuration>
            </code>
            <param>
            Of course you don't have to do it like that if you don't want to.
            </param>
            <param>
            If you need to monitor this file for changes and reload the
            configuration when the config file's contents changes then
            you should use the <see cref="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)"/> method
            instead.
            </param>
            </remarks>
            <seealso cref="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)"/>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
            <summary>
            Configure log4net using the config file specified.
            </summary>
            <param name="repository">the repository to configure</param>
            <param name="configFile">the XML config file to load
            the configuration from</param>
            <remarks>
            The configuration file must be valid XML. It must contain
            at least one element called <c>log4net</c> that holds
            the configuration data.
            <para>
            The logging file could be specified in the applications
            configuration file (either <c>MyAppName.exe.config</c> for a
            normal application on <c>Web.config</c> for an ASP.NET application).
            To Load the configuration use code like:
            </para>
            <code>
            using log4net.Config;
            using System.IO;
            using System.Configuration;

            ...

            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));
            </code>
            <para>In your <c>.config</c> file you must specify the config file to
            use like this:</para>
            <code>
            <configuration>
                <appSettings>
                    <add key="log4net-config-file" value="log.config"/>
                </appSettings>
            </configuration>
            </code>
            <param>
            Of course you don't have to do it like that if you don't want to.
            </param>
            <param>
            If you need to monitor this file for changes and reload the
            configuration when the config file's contents changes then
            you should use the <see cref="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)"/> method
            instead.
            </param>
            </remarks>
            <seealso cref="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)"/>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">
            <summary>
            Configure log4net using the file specified, monitor the file for changes
            and reload the configuration if a change is detected.
            </summary>
            <param name="configFile">the XML config file to load
            the configuration from</param>
            <remarks>
            The configuration file must be valid XML. It must contain
            at least one element called <c>log4net</c> that holds
            the configuration data.
            <para>
            The config file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
            and is dependant on the behaviour of that class.
            </para>
            <para>
            For more information on how to configure log4net using
            a seperate config file see <see cref="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)"/>.
            </para>
            </remarks>
            <seealso cfer="Configure(FileInfo)"/>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
            <summary>
            Configure log4net using the file specified, monitor the file for changes
            and reload the configuration if a change is detected.
            </summary>
            <param name="repository">the repository to configure</param>
            <param name="configFile">the XML config file to load
            the configuration from</param>
            <remarks>
            The configuration file must be valid XML. It must contain
            at least one element called <c>log4net</c> that holds
            the configuration data.
            <para>
            The config file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>
            and is dependant on the behaviour of that class.
            </para>
            <para>
            For more information on how to configure log4net using
            a seperate config file see <see cref="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)"/>.
            </para>
            </remarks>
            <seealso cfer="Configure(FileInfo)"/>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.ConfigureFromXML(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">
            <summary>
            Configure log4net using a <c>log4net</c> element
            </summary>
            <param name="repository">the hierarchy to configure</param>
            <param name="element">the element to parse</param>
            <remarks>
            <para>Load the log4net configuration from the XML element
            supplied as <paramref name="element"/>.</para>

            <para>This private static method is ultimatly called
            by one of the Configure methods to load the configuration
            from an <see cref="T:System.Xml.XmlElement"/>.</para>
            </remarks>
        </member>
        <member name="T:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler">
            <summary>
            Internal class used to watch config files
            </summary>
        </member>
        <member name="F:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler.m_configFile">
            <summary>
            Hold the FileInfo used to configure the DOMConfigurator
            </summary>
        </member>
        <member name="F:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler.m_repository">
            <summary>
            hold on to the repository being configured
            </summary>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">
            <summary>
            Construct a new watch handler.
            </summary>
            <param name="repository">the repository to configure</param>
            <param name="configFile">the config file to watch</param>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">
            <summary>
            Event handler used by <see cref="T:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler"/>.
            </summary>
            <param name="source">the <see cref="T:System.IO.FileSystemWatcher"/> firing the event</param>
            <param name="e">the argument indicates the file that caused the event to be fired</param>
            <remarks>
            This handler reloads the configuration from the file when the event is fired.
            </remarks>
        </member>
        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">
            <summary>
            Event handler used by <see cref="T:log4net.Config.DOMConfigurator.ConfigureAndWatchHandler"/>.
            </summary>
            <param name="source">the <see cref="T:System.IO.FileSystemWatcher"/> firing the event</param>
            <param name="e">the argument indicates the file that caused the event to be fired</param>
            <remarks>
            This handler reloads the configuration from the file when the event is fired.
            </remarks>
        </member>
        <member name="T:log4net.Config.DOMConfiguratorAttribute">
            <summary>
            Assembly level attribute to configure the <see cref="T:log4net.Config.DOMConfigurator"/>
            </summary>
            <remarks>
            <para>This attribute may only be used at the assembly scope and can only
            be used once per assembly.</para>
            <para>Use this attribute to configure the <see cref="T:log4net.Config.DOMConfigurator"/>
            without calling one of the <see cref="M:log4net.Config.DOMConfigurator.Configure"/>
            methods.</para>
            </remarks>
        </member>
        <member name="M:log4net.Config.DOMConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
            <summary>
            Configure the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
            </summary>
            <param name="assembly">The assembly that this attribute was defined on</param>
            <param name="repository">The repository to configure</param>
            <remarks>
            <para>Configure the repository using the <see cref="T:log4net.Config.DOMConfigurator"/>.
            The <paramref name="repository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>
            class otherwise the <see cref="T:log4net.Config.DOMConfigurator"/> will not be able to
            configure it.</para>
            </remarks>
            <exception cref="T:System.ArgumentOutOfRangeException">Thrown if the <c>repository</c> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/></exception>
        </member>
        <member name="P:log4net.Config.DOMConfiguratorAttribute.ConfigFile">
            <summary>
            Optional. Specify the filename of the config file
            </summary>
            <remarks>
            <para>If specified this is the name of the configuration file to use with
            the <see cref="T:log4net.Config.DOMConfigurator"/>. This file path is relative to the
            <b>application base</b> directory (<see cref="P:System.AppDomain.CurrentDomain"/>).</para>
            </remarks>
        </member>
        <member name="P:log4net.Config.DOMConfiguratorAttribute.ConfigFileExtension">
            <summary>
            Optional. The extention of the config file
            </summary>
            <remarks>
            <para>If specified this is the extension for the configuration file.
            The path to the config file is build by using the <b>application
            base</b> directory (<see cref="P:System.AppDomain.CurrentDomain"/>),
            the <b>assembly name</b> and the config file extension.</para>
            <code>
                Application Base Path\Assembly.dll.logging extention
            </code>
            </remarks>
        </member>
        <member name="P:log4net.Config.DOMConfiguratorAttribute.Watch">
            <summary>
            Optional. Set to true to watch the configuration file.
            </summary>
            <remarks>
            <para>If this flag is specified and set to true then the framework
            will watch the configuration file and will reload the config
            each time the file is modified.</para>
            </remarks>
        </member>
        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
            <summary>
            Class to register for the log4net section of the configuration file
            </summary>
            <remarks>
            The log4net section of the configuration file needs to have a section
            handler registered. This is the section handler used. It simply returns
            the XML element that is the root of the section.
            </remarks>
            <example>
            Example of registering the section handler
            <code>
            <?xml version="1.0" encoding="utf-8" ?>
            <configuration>
                <configSections>
                    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
                </configSections>
                <log4net>
                    log4net configuration XML goes here
                </log4net>
            </configuration>
            </code>
            </example>
        </member>
        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
            <summary>
            method called to parse the configuration section
            </summary>
            <param name="parent">ignored</param>
            <param name="configContext">ignored</param>
            <param name="section">the XML node for the section</param>
            <returns>the XML node for the section</returns>
        </member>
        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">
            <summary>
            Formats a <see cref="T:System.DateTime"/> in the format "HH:mm:ss,SSS" for example, "15:49:37,459".
            </summary>
            <remarks>
            Formats a <see cref="T:System.DateTime"/> in the format "HH:mm:ss,SSS" for example, "15:49:37,459".
            </remarks>
        </member>
        <member name="T:log4net.DateFormatter.IDateFormatter">
            <summary>
            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
            instance into a string.
            </summary>
            <remarks>
            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>
            instance into a string.
            </remarks>
        </member>
        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.Text.StringBuilder)">
            <summary>
            Format the date specifed as a string
            </summary>
            <param name="date">the date to format</param>
            <param name="buf">the string builder to write to</param>
            <returns>the string builder passed</returns>
            <remarks>
            Format the date specifed as a string
            </remarks>
        </member>
        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.ABS_TIME_DATE_FORMAT">
            <summary>
            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.
            </summary>
        </member>
        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DATE_AND_TIME_DATE_FORMAT">
            <summary>
            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.
            </summary>
        </member>
        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.ISO8601_DATE_FORMAT">
            <summary>
            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.
            </summary>
        </member>
        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
            <summary>
            Render the date into a string. Format is "HH:mm:ss"
            </summary>
            <remarks>
            Sub classes should override this method to render the date
            into a string using a precision up to the sencond. This method
            will be called at most once per second and the result will be
            reused if it is needed again during the same second.
            </remarks>
            <param name="date">the date to render into a string</param>
            <param name="sbuf">a string builder to write to</param>
        </member>
        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.Text.StringBuilder)">
            <summary>
            Render the date into a string. Format is "HH:mm:ss,SSS"
            </summary>
            <remarks>
            <para>Uses the FormatDateWithoutMillis() method to generate the
            time string up to the seconds and then appends the current
            milliseconds. The results from FormatDateWithoutMillis() are
            cached and FormatDateWithoutMillis() is called at most once
            per second.</para>
            <para>Sub classes should override FormatDateWithoutMillis()
            rather than FormatDate().</para>
            </remarks>
            <param name="date">the date to render into a string</param>
            <param name="sbuf">a string builder to write to</param>
            <returns>the string builder passed</returns>
        </member>
        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">
            <summary>
            Formats a <see cref="T:System.DateTime"/> in the format "dd MMM YYYY HH:mm:ss,SSS" for example, "06 Nov 1994 15:49:37,459".
            </summary>
            <remarks>
            Formats a <see cref="T:System.DateTime"/> in the format "dd MMM YYYY HH:mm:ss,SSS" for example, "06 Nov 1994 15:49:37,459".
            </remarks>
        </member>
        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_shortMonths">
            <summary>
            Cache the list of month names
            </summary>
        </member>
        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
            <summary>
            Formats the date as: "dd MMM YYYY HH:mm:ss"
            the base class will append the ',SSS' milliseconds section.
            We will only be called at most once per second.
            </summary>
            <remarks>
            Formats a DateTime in the format "dd MMM YYYY HH:mm:ss" for example, "06 Nov 1994 15:49:37".
            </remarks>
            <param name="date">the date to format</param>
            <param name="sbuf">the string builder to write to</param>
        </member>
        <member name="T:log4net.DateFormatter.ISO8601DateFormatter">
            <summary>
            Format the <see cref="T:System.DateTime"/> specifed as a string: 'YYYY-MM-dd HH:mm:ss,SSS'
            </summary>
            <remarks>
            Format the <see cref="T:System.DateTime"/> specifed as a string: 'YYYY-MM-dd HH:mm:ss,SSS'
            </remarks>
        </member>
        <member name="M:log4net.DateFormatter.ISO8601DateFormatter.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:log4net.DateFormatter.ISO8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">
            <summary>
            Format the date specifed as a string: 'YYYY-MM-dd HH:mm:ss'
            the base class will append the ',SSS' milliseconds section.
            We will only be called at most once per second.
            </summary>
            <param name="date">the date to format</param>
            <param name="sbuf">the string builder to write to</param>
        </member>
        <member name="T:log4net.DateFormatter.SimpleDateFormatter">
            <summary>
            Format the <see cref="T:System.DateTime"/> using the <see cref="M:System.DateTime.ToString"/> method.
            </summary>
            <remarks>
            Format the <see cref="T:System.DateTime"/> using the <see cref="M:System.DateTime.ToString"/> method.
            </remarks>
        </member>
        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">
            <summary>
            The format string must be compatible with the options
            that can be supplied to <see cref="M:System.DateTime.ToString"/>.
            </summary>
        </member>
        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">
            <summary>
            Construct a simple date formatter with a format string
            </summary>
            <remarks>
            The format string must be compatible with the options
            that can be supplied to <see cref="M:System.DateTime.ToString"/>.
            </remarks>
            <param name="formatString">the format string</param>
        </member>
        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.Text.StringBuilder)">
            <summary>
            Format the date using <see cref="M:System.DateTime.ToString"/>
            </summary>
            <param name="date">the date to convert to a string</param>
            <param name="buf">the builder to write to</param>
            <returns>the builder passed</returns>
        </member>
        <member name="T:log4net.Filter.DenyAllFilter">
            <summary>
            This filter drops all <see cref="T:log4net.spi.LoggingEvent"/>.
            </summary>
            <remarks>
            You can add this filter to the end of a filter chain to
            switch from the default "accept all unless instructed otherwise"
            filtering behaviour to a "deny all unless instructed otherwise"
            behaviour.
            </remarks>
        </member>
        <member name="T:log4net.Filter.FilterSkeleton">
            <summary>
            Users should extend this class to implement customized logging
            event filtering.
            </summary>
            <remarks>
            <para>Users should extend this class to implement customized logging
            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and
            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
            appenders, have built-in filtering rules. It is suggested that you
            first use and understand the built-in rules before rushing to write
            your own custom filters.</para>

            <para>This abstract class assumes and also imposes that filters be
            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.spi.LoggingEvent)"/>
            method of each filter is called sequentially, in the order of their
            addition to the chain.</para>

            <para>The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.spi.LoggingEvent)"/> method must return one
            of the integer constants <see cref="F:log4net.Filter.FilterDecision.DENY"/>, <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/> or <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/>.</para>

            <para>If the value <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned, then the log event is dropped
            immediately without consulting with the remaining filters. </para>

            <para>If the value <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/> is returned, then the next filter
            in the chain is consulted. If there are no more filters in the
            chain, then the log event is logged. Thus, in the presence of no
            filters, the default behaviour is to log all logging events.</para>

            <para>If the value <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> is returned, then the log
            event is logged without consulting the remaining filters. </para>

            <para>The philosophy of log4net filters is largely inspired from the
            Linux ipchains. </para>
            </remarks>
        </member>
        <member name="T:log4net.Filter.IFilter">
            <summary>
            Users should implement this interface to implement customized logging
            event filtering.
            </summary>
            <remarks>
            <para>Users should implement this interface to implement customized logging
            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and
            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
            appenders, have built-in filtering rules. It is suggested that you
            first use and understand the built-in rules before rushing to write
            your own custom filters.</para>

            <para>This abstract class assumes and also imposes that filters be
            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.spi.LoggingEvent)"/>
            method of each filter is called sequentially, in the order of their
            addition to the chain.</para>

            <para>The <see cref="M:log4net.Filter.IFilter.Decide(log4net.spi.LoggingEvent)"/> method must return one
            of the integer constants <see cref="F:log4net.Filter.FilterDecision.DENY"/>,
            <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/> or <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/>.</para>

            <para>If the value <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned, then the log event is dropped
            immediately without consulting with the remaining filters. </para>

            <para>If the value <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/> is returned, then the next filter
            in the chain is consulted. If there are no more filters in the
            chain, then the log event is logged. Thus, in the presence of no
            filters, the default behaviour is to log all logging events.</para>

            <para>If the value <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> is returned, then the log
            event is logged without consulting the remaining filters. </para>

            <para>The philosophy of log4net filters is largely inspired from the
            Linux ipchains.</para>
            </remarks>
        </member>
        <member name="M:log4net.Filter.IFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Decide if the logging event should be logged through an appender.
            </summary>
            <param name="loggingEvent">The LoggingEvent to decide upon</param>
            <returns>The decision of the filter</returns>
            <remarks>
            <para>If the decision is <see cref="F:log4net.Filter.FilterDecision.DENY"/>, then the event will be
            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/>, then the next
            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> then
            the event will be logged without consulting with other filters in
            the chain.</para>
            </remarks>
        </member>
        <member name="P:log4net.Filter.IFilter.Next">
            <summary>
            Property to get and set the next filter in the filter
            chain of responsability.
            </summary>
            <value>
            The next filter in the chain
            </value>
            <remarks>
            Filters are typicaly composed into chains. This property allows the next filter in
            the chain to be accessed.
            </remarks>
        </member>
        <member name="F:log4net.Filter.FilterSkeleton.m_next">
            <summary>
            Points to the next filter in the filter chain.
            </summary>
            <remarks>
            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
            </remarks>
        </member>
        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
            <summary>
            Usually filters options become active when set.
            We provide a default do-nothing implementation for convenience.
            </summary>
        </member>
        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Decide if the <see cref="T:log4net.spi.LoggingEvent"/> should be logged through an appender.
            </summary>
            <param name="loggingEvent">The <see cref="T:log4net.spi.LoggingEvent"/> to decide upon</param>
            <returns>The decision of the filter</returns>
            <remarks>
            <para>If the decision is <see cref="F:log4net.Filter.FilterDecision.DENY"/>, then the event will be
            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/>, then the next
            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> then
            the event will be logged without consulting with other filters in
            the chain.</para>

            <para>This method is marked <c>abstract</c> and must be implemented
            in a subclass.</para>
            </remarks>
        </member>
        <member name="P:log4net.Filter.FilterSkeleton.Next">
            <summary>
            Property to get and set the next filter in the filter
            chain of responsability.
            </summary>
            <value>
            The next filter in the chain
            </value>
            <remarks>
            Filters are typicaly composed into chains. This property allows the next filter in
            the chain to be accessed.
            </remarks>
        </member>
        <member name="M:log4net.Filter.DenyAllFilter.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.DENY"/>
            </summary>
            <remarks>
            Ignores the event being logged and just returns
            <see cref="F:log4net.Filter.FilterDecision.DENY"/>. This can be used to change the default filter
            chain behaviour from <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> to <see cref="F:log4net.Filter.FilterDecision.DENY"/>. This filter
            should only be used as the last filter in the chain
            as any further filters will be ignored!
            </remarks>
            <param name="loggingEvent">the LoggingEvent to filter</param>
            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.DENY"/></returns>
        </member>
        <member name="T:log4net.Filter.FilterDecision">
            <summary>
            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.spi.LoggingEvent)"/>
            </summary>
            <remarks>
            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.spi.LoggingEvent)"/>
            </remarks>
        </member>
        <member name="F:log4net.Filter.FilterDecision.DENY">
            <summary>
            The log event must be dropped immediately without
            consulting with the remaining filters, if any, in the chain.
            </summary>
        </member>
        <member name="F:log4net.Filter.FilterDecision.NEUTRAL">
            <summary>
            This filter is neutral with respect to the log event.
            The remaining filters, if any, should be consulted for a final decision.
            </summary>
        </member>
        <member name="F:log4net.Filter.FilterDecision.ACCEPT">
            <summary>
            The log event must be logged immediately without
            consulting with the remaining filters, if any, in the chain.
            </summary>
        </member>
        <member name="T:log4net.Filter.LevelMatchFilter">
            <summary>
            This is a very simple filter based on <see cref="T:log4net.spi.Level"/> matching.
            </summary>
            <remarks>
            <para>The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and
            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value
            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.spi.Level"/> of the
            <see cref="T:log4net.spi.LoggingEvent"/>, then the <see cref="M:log4net.Filter.LevelMatchFilter.Decide(log4net.spi.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> in
            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set
            to <c>true</c>, if it is <c>false</c> then
            <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned.</para>
            </remarks>
        </member>
        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">
            <summary>
            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> on a match
            </summary>
        </member>
        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">
            <summary>
            the <see cref="T:log4net.spi.Level"/> to match agains
            </summary>
        </member>
        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Tests if the <see cref="T:log4net.spi.Level"/> of the logging event matches that of the filter
            </summary>
            <remarks>
            If the <see cref="T:log4net.spi.Level"/> of the event matches the level of the
            filter then the result of the function depends on the
            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then
            the function will return <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/>, it it is false then it
            will return <see cref="F:log4net.Filter.FilterDecision.DENY"/>. If the <see cref="T:log4net.spi.Level"/> does not match then
            the result will be the opposite of when it does match.
            </remarks>
            <param name="loggingEvent">the event to filter</param>
            <returns>see remarks</returns>
        </member>
        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">
            <summary>
            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines
            the behaviour when a matching <see cref="T:log4net.spi.Level"/> is found. If the
            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> the
            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.DENY"/> the event.
            </summary>
        </member>
        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">
            <summary>
            The <see cref="T:log4net.spi.Level"/> that the filter will match
            </summary>
        </member>
        <member name="T:log4net.Filter.LevelRangeFilter">
            <summary>
            This is a simple filter based on <see cref="T:log4net.spi.Level"/> matching.
            </summary>
            <remarks>
            <para>The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>
            that determine the range of priorites that are matched, and
            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range
            of priorities and the <see cref="T:log4net.spi.Level"/> of the <see cref="T:log4net.spi.LoggingEvent"/>, then the
            <see cref="M:log4net.Filter.LevelRangeFilter.Decide(log4net.spi.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> in case the <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>
            option value is set to <c>true</c>, if it is <c>false</c>
            then <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned.</para>
            </remarks>
        </member>
        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">
            <summary>
            Flag to indicate the behaviour when matching a <see cref="T:log4net.spi.Level"/>
            </summary>
        </member>
        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">
            <summary>
            the minimum <see cref="T:log4net.spi.Level"/> value to match
            </summary>
        </member>
        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">
            <summary>
            the maximum <see cref="T:log4net.spi.Level"/> value to match
            </summary>
        </member>
        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">
            <summary>
            Default constuctor
            </summary>
        </member>
        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Check if the event should be logged.
            </summary>
            <remarks>
            If the <see cref="T:log4net.spi.Level"/> of the logging event is outside the range
            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.DENY"/>
            is returned. If the <see cref="T:log4net.spi.Level"/> is matched then the value of
            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then
            <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> is returned, otherwise
            <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/> is returned.
            </remarks>
            <param name="loggingEvent">the logging event to check</param>
            <returns>see remarks</returns>
        </member>
        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">
            <summary>
            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines
            the behaviour when a matching <see cref="T:log4net.spi.Level"/> is found. If the
            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> the
            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/> the event.
            </summary>
        </member>
        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">
            <summary>
            Set the minimum matched <see cref="T:log4net.spi.Level"/>
            </summary>
        </member>
        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">
            <summary>
            Sets the maximum matched <see cref="T:log4net.spi.Level"/>
            </summary>
        </member>
        <member name="T:log4net.Filter.MDCFilter">
            <summary>
            Simple filter to match a string in the <see cref="T:log4net.MDC"/>
            </summary>
            <remarks>
            Simple filter to match a string in the <see cref="T:log4net.MDC"/>
            </remarks>
        </member>
        <member name="F:log4net.Filter.MDCFilter.m_acceptOnMatch">
            <summary>
            Flag to indicate the behaviour when we have a match
            </summary>
        </member>
        <member name="F:log4net.Filter.MDCFilter.m_stringToMatch">
            <summary>
            The string to substring match against the message
            </summary>
        </member>
        <member name="F:log4net.Filter.MDCFilter.m_stringRegexToMatch">
            <summary>
            A string regext to match
            </summary>
        </member>
        <member name="F:log4net.Filter.MDCFilter.m_regexToMatch">
            <summary>
            A regex object to match (generated from m_stringRegexToMatch)
            </summary>
        </member>
        <member name="F:log4net.Filter.MDCFilter.m_key">
            <summary>
            The key to use to lookup the string
            from the MDC
            </summary>
        </member>
        <member name="M:log4net.Filter.MDCFilter.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Filter.MDCFilter.ActivateOptions">
            <summary>
            Initialise and precompile the Regex if required
            </summary>
        </member>
        <member name="M:log4net.Filter.MDCFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Check if this filter should allow the event to be logged
            </summary>
            <remarks>
            The <see cref="T:log4net.MDC"/> is mached agains the <see cref="P:log4net.Filter.MDCFilter.StringToMatch"/>.
            If the <see cref="P:log4net.Filter.MDCFilter.StringToMatch"/> occurs as a substring within
            the message then a match will have occured. If no match occures
            this function will return <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/>
            allowing other filters to check the event. If a match occurs then
            the value of <see cref="P:log4net.Filter.MDCFilter.AcceptOnMatch"/> is checked. If it is
            true then <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> is returned otherwise
            <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned.
            </remarks>
            <param name="loggingEvent">the event being logged</param>
            <returns>see remarks</returns>
        </member>
        <member name="P:log4net.Filter.MDCFilter.AcceptOnMatch">
            <summary>
            The <see cref="P:log4net.Filter.MDCFilter.AcceptOnMatch"/> property is a flag that determines
            the behaviour when a matching <see cref="T:log4net.spi.Level"/> is found. If the
            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> the
            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.DENY"/> the event.
            </summary>
        </member>
        <member name="P:log4net.Filter.MDCFilter.StringToMatch">
            <summary>
            The string that will be substring matched against
            the rendered message. If the message contains this
            string then the filter will match.
            </summary>
        </member>
        <member name="P:log4net.Filter.MDCFilter.RegexToMatch">
            <summary>
            The regular expression pattern that will be matched against
            the rendered message. If the message matches this
            pattern then the filter will match.
            </summary>
        </member>
        <member name="P:log4net.Filter.MDCFilter.Key">
            <summary>
            The key to lookup in the <see cref="T:log4net.MDC"/> and then
            match against.
            </summary>
        </member>
        <member name="T:log4net.Filter.NDCFilter">
            <summary>
            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
            </summary>
            <remarks>
            Simple filter to match a string in the <see cref="T:log4net.NDC"/>
            </remarks>
        </member>
        <member name="F:log4net.Filter.NDCFilter.m_acceptOnMatch">
            <summary>
            Flag to indicate the behaviour when we have a match
            </summary>
        </member>
        <member name="F:log4net.Filter.NDCFilter.m_stringToMatch">
            <summary>
            The string to substring match against the message
            </summary>
        </member>
        <member name="F:log4net.Filter.NDCFilter.m_stringRegexToMatch">
            <summary>
            A string regext to match
            </summary>
        </member>
        <member name="F:log4net.Filter.NDCFilter.m_regexToMatch">
            <summary>
            A regex object to match (generated from m_stringRegexToMatch)
            </summary>
        </member>
        <member name="M:log4net.Filter.NDCFilter.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Filter.NDCFilter.ActivateOptions">
            <summary>
            Initialise and precompile the Regex if required
            </summary>
        </member>
        <member name="M:log4net.Filter.NDCFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Check if this filter should allow the event to be logged
            </summary>
            <remarks>
            The <see cref="T:log4net.NDC"/> is mached agains the <see cref="P:log4net.Filter.NDCFilter.StringToMatch"/>.
            If the <see cref="P:log4net.Filter.NDCFilter.StringToMatch"/> occurs as a substring within
            the message then a match will have occured. If no match occures
            this function will return <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/>
            allowing other filters to check the event. If a match occurs then
            the value of <see cref="P:log4net.Filter.NDCFilter.AcceptOnMatch"/> is checked. If it is
            true then <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> is returned otherwise
            <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned.
            </remarks>
            <param name="loggingEvent">the event being logged</param>
            <returns>see remarks</returns>
        </member>
        <member name="P:log4net.Filter.NDCFilter.AcceptOnMatch">
            <summary>
            The <see cref="P:log4net.Filter.NDCFilter.AcceptOnMatch"/> property is a flag that determines
            the behaviour when a matching <see cref="T:log4net.spi.Level"/> is found. If the
            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> the
            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.DENY"/> the event.
            </summary>
        </member>
        <member name="P:log4net.Filter.NDCFilter.StringToMatch">
            <summary>
            The string that will be substring matched against
            the rendered message. If the message contains this
            string then the filter will match.
            </summary>
        </member>
        <member name="P:log4net.Filter.NDCFilter.RegexToMatch">
            <summary>
            The regular expression pattern that will be matched against
            the rendered message. If the message matches this
            pattern then the filter will match.
            </summary>
        </member>
        <member name="T:log4net.Filter.StringMatchFilter">
            <summary>
            Simple filter to match a string in the rendered message
            </summary>
            <remarks>
            Simple filter to match a string in the rendered message
            </remarks>
        </member>
        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">
            <summary>
            Flag to indicate the behaviour when we have a match
            </summary>
        </member>
        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">
            <summary>
            The string to substring match against the message
            </summary>
        </member>
        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">
            <summary>
            A string regext to match
            </summary>
        </member>
        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">
            <summary>
            A regex object to match (generated from m_stringRegexToMatch)
            </summary>
        </member>
        <member name="M:log4net.Filter.StringMatchFilter.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">
            <summary>
            Initialise and precompile the Regex if required
            </summary>
        </member>
        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.spi.LoggingEvent)">
            <summary>
            Check if this filter should allow the event to be logged
            </summary>
            <remarks>
            The rendered message is mached agains the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.
            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within
            the message then a match will have occured. If no match occures
            this function will return <see cref="F:log4net.Filter.FilterDecision.NEUTRAL"/>
            allowing other filters to check the event. If a match occurs then
            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is
            true then <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> is returned otherwise
            <see cref="F:log4net.Filter.FilterDecision.DENY"/> is returned.
            </remarks>
            <param name="loggingEvent">the event being logged</param>
            <returns>see remarks</returns>
        </member>
        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">
            <summary>
            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines
            the behaviour when a matching <see cref="T:log4net.spi.Level"/> is found. If the
            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.ACCEPT"/> the
            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.DENY"/> the event.
            </summary>
        </member>
        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">
            <summary>
            The string that will be substring matched against
            the rendered message. If the message contains this
            string then the filter will match.
            </summary>
        </member>
        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">
            <summary>
            The regular expression pattern that will be matched against
            the rendered message. If the message matches this
            pattern then the filter will match.
            </summary>
        </member>
        <member name="T:log4net.helpers.AppenderAttachedImpl">
            <summary>
            A straightforward implementation of the <see cref="T:log4net.spi.IAppenderAttachable"/> interface.
            </summary>
        </member>
        <member name="T:log4net.spi.IAppenderAttachable">
            <summary>
            Interface for attaching appenders to objects.
            </summary>
        </member>
        <member name="M:log4net.spi.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
            <summary>
            Add an appender.
            </summary>
            <param name="newAppender"></param>
        </member>
        <member name="M:log4net.spi.IAppenderAttachable.GetAllAppenders">
            <summary>
            Get all previously added appenders as an Enumeration.
            </summary>
            <returns></returns>
        </member>
        <member name="M:log4net.spi.IAppenderAttachable.GetAppender(System.String)">
            <summary>
            Get an appender by name.
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:log4net.spi.IAppenderAttachable.RemoveAllAppenders">
            <summary>
            Remove all previously added appenders.
            </summary>
        </member>
        <member name="M:log4net.spi.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
            <summary>
            Remove the appender passed as parameter from the list of appenders.
            </summary>
            <param name="appender"></param>
        </member>
        <member name="M:log4net.spi.IAppenderAttachable.RemoveAppender(System.String)">
            <summary>
            Remove the appender with the name passed as parameter from the list of appenders.
            </summary>
            <param name="name"></param>
        </member>
        <member name="F:log4net.helpers.AppenderAttachedImpl.m_appenderList">
            <summary>
            Array of appenders
            </summary>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.spi.LoggingEvent)">
            <summary>
            Call the <c>DoAppend</c> method on all attached appenders.
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the number of appenders called</returns>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">
            <summary>
            Attach an appender. If the appender is already in the list in won't be added again.
            </summary>
            <param name="newAppender">the appender to add</param>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.GetAllAppenders">
            <summary>
            Get all attached appenders as a Collection. If there are
            no attached appenders <c>null</c> is returned.
            </summary>
            <returns>A collection of attached appenders</returns>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.GetAppender(System.String)">
            <summary>
            Look for an attached appender named as <paramref name="name"/>.
            </summary>
            <remarks>
            Return the appender with that name if in the list. Return <c>null</c> otherwise.
            </remarks>
            <param name="name">name of the appender to get</param>
            <returns>the appender with the name specified, or null</returns>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.RemoveAllAppenders">
            <summary>
            Remove all previously attached appenders
            </summary>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">
            <summary>
            Remove the appender passed as parameter form the list of attached appenders
            </summary>
            <param name="appender">the appender object to remove</param>
        </member>
        <member name="M:log4net.helpers.AppenderAttachedImpl.RemoveAppender(System.String)">
            <summary>
            Remove the appender with the name passed as parameter form the list of appenders
            </summary>
            <param name="name">the name of the appender to remove</param>
        </member>
        <member name="T:log4net.helpers.CountingQuietTextWriter">
            <summary>
            Subclass of <see cref="T:log4net.helpers.QuietTextWriter"/> that maintains a count of the number of bytes written
            </summary>
        </member>
        <member name="T:log4net.helpers.QuietTextWriter">
            <summary>
            QuietTextWriter does not throw exceptions when things go wrong.
            Instead, it delegates error handling to its <see cref="T:log4net.spi.IErrorHandler"/>.
            </summary>
        </member>
        <member name="F:log4net.helpers.QuietTextWriter.m_errorHandler">
            <summary>
            The error handler instance to pass all errors to
            </summary>
        </member>
        <member name="F:log4net.helpers.QuietTextWriter.m_writer">
            <summary>
            The instance of the underlying TextWriter used for output
            </summary>
        </member>
        <member name="F:log4net.helpers.QuietTextWriter.m_closed">
            <summary>
            Flag to indicate if this writer is closed
            </summary>
        </member>
        <member name="M:log4net.helpers.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.spi.IErrorHandler)">
            <summary>
            Create a new QuietTextWriter using a writer and error handler
            </summary>
            <param name="writer">the writer to actualy write to</param>
            <param name="errorHandler">the error handler to report error to</param>
        </member>
        <member name="M:log4net.helpers.QuietTextWriter.Write(System.String)">
            <summary>
            Write a string to the output
            </summary>
            <param name="str">the string data to write to the output</param>
        </member>
        <member name="M:log4net.helpers.QuietTextWriter.Flush">
            <summary>
            Flush any buffered output
            </summary>
        </member>
        <member name="M:log4net.helpers.QuietTextWriter.Close">
            <summary>
            Close the underlying output writer
            </summary>
        </member>
        <member name="P:log4net.helpers.QuietTextWriter.ErrorHandler">
            <summary>
            The error handler that all errors are passed to
            </summary>
        </member>
        <member name="P:log4net.helpers.QuietTextWriter.Closed">
            <summary>
            Flag to indicate if this writer is closed
            </summary>
            <value>
            Flag to indicate if this writer is closed
            </value>
        </member>
        <member name="F:log4net.helpers.CountingQuietTextWriter.m_countBytes">
            <summary>
            member variable to hold the total count of chars written
            </summary>
        </member>
        <member name="F:log4net.helpers.CountingQuietTextWriter.m_encoding">
            <summary>
            The encoding used to convert strings into bytes
            </summary>
        </member>
        <member name="M:log4net.helpers.CountingQuietTextWriter.#ctor(System.IO.TextWriter,System.Text.Encoding,log4net.spi.IErrorHandler)">
            <summary>
            Create a new CountingQuietTextWriter using a writer and error handler
            </summary>
            <param name="writer">the writer to actualy write to</param>
            <param name="encoding">the encoding to use to convert strings to bytes</param>
            <param name="errorHandler">the error handler to report error to</param>
        </member>
        <member name="M:log4net.helpers.CountingQuietTextWriter.Write(System.String)">
            <summary>
            Write a string to the output. Count the number of bytes written.
            </summary>
            <param name="str">the string data to write to the output</param>
        </member>
        <member name="P:log4net.helpers.CountingQuietTextWriter.Count">
            <summary>
            The total number of bytes written
            </summary>
        </member>
        <member name="T:log4net.helpers.CyclicBuffer">
            <summary>
            A fixed size rolling buffer of logging events.
            </summary>
        </member>
        <member name="M:log4net.helpers.CyclicBuffer.#ctor(System.Int32)">
            <summary>
            Instantiate a new CyclicBuffer of at most <paramref name="maxSize"/> events.
            </summary>
            <remarks>The <paramref name="maxSize"/> argument must a positive integer.</remarks>
            <param name="maxSize">The maximum number of elements in the buffer</param>
        </member>
        <member name="M:log4net.helpers.CyclicBuffer.Append(log4net.spi.LoggingEvent)">
            <summary>
            Add an <paramref name="loggingEvent"/> as the last event in the buffer
            </summary>
            <param name="loggingEvent">The event to append to the buffer</param>
            <returns>true if the buffer is not full</returns>
        </member>
        <member name="M:log4net.helpers.CyclicBuffer.PopOldest">
            <summary>
            Get the oldest (first) element in the buffer. The oldest element is removed from the buffer.
            </summary>
            <returns></returns>
        </member>
        <member name="M:log4net.helpers.CyclicBuffer.PopAll">
            <summary>
            Pop all the events from the buffer into an array
            </summary>
            <returns>an array of all the events in the buffer</returns>
        </member>
        <member name="M:log4net.helpers.CyclicBuffer.Resize(System.Int32)">
            <summary>
            Resize the cyclic buffer to <paramref name="newSize"/>.
            </summary>
            <param name="newSize">the new size of the buffer, must be greater than zero</param>
        </member>
        <member name="P:log4net.helpers.CyclicBuffer.Item(System.Int32)">
            <summary>
            Get the <paramref name="i"/>th oldest event currently in the buffer
            </summary>
            <remarks>
            Get the <paramref name="i"/>th oldest event currently in the buffer. If
            <paramref name="i"/> is outside the range 0 to the number of elements
            currently in the buffer, then <c>null</c> is returned.
            </remarks>
        </member>
        <member name="P:log4net.helpers.CyclicBuffer.MaxSize">
            <summary>
            Get the maximum size of the buffer
            </summary>
        </member>
        <member name="P:log4net.helpers.CyclicBuffer.Length">
            <summary>
            Get the number of elements in the buffer. This number is
            guaranteed to be in the range 0 to <see cref="P:log4net.helpers.CyclicBuffer.MaxSize"/>
            (inclusive).
            </summary>
        </member>
        <member name="T:log4net.helpers.EmptyCollection">
            <summary>
            An allways empty <see cref="T:System.Collections.ICollection"/>.
            </summary>
        </member>
        <member name="F:log4net.helpers.EmptyCollection.s_instance">
            <summary>
            The singleton instance of the empty collection
            </summary>
        </member>
        <member name="M:log4net.helpers.EmptyCollection.#ctor">
            <summary>
            Private constructor to enforce the singleton pattern
            </summary>
        </member>
        <member name="M:log4net.helpers.EmptyCollection.CopyTo(System.Array,System.Int32)">
            <summary>
            copies the elements of the <see cref="T:System.Collections.ICollection"/> to an
            <see cref="T:System.Array"/>, starting at a particular Array index.
            </summary>
            <param name="array">The one-dimensional <see cref="T:System.Array"/>
            that is the destination of the elements copied from
            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based
            indexing.</param>
            <param name="index">The zero-based index in array at which
            copying begins.</param>
        </member>
        <member name="M:log4net.helpers.EmptyCollection.GetEnumerator">
            <summary>
            Returns an enumerator that can iterate through a collection
            </summary>
            <returns>An <see cref="T:System.Collections.IEnumerator"/> that can be used to
            iterate through the collection</returns>
        </member>
        <member name="P:log4net.helpers.EmptyCollection.Instance">
            <summary>
            Get the singleton instance of the empty Collection
            </summary>
            <returns>get the instance of the empty Collection</returns>
        </member>
        <member name="P:log4net.helpers.EmptyCollection.IsSynchronized">
            <summary>
            gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).
            </summary>
            <value>
            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.
            </value>
            <remarks>
            For the <see cref="T:log4net.helpers.EmptyCollection"/> this property is allways <b>true</b>.
            </remarks>
        </member>
        <member name="P:log4net.helpers.EmptyCollection.Count">
            <summary>
            gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>
            </summary>
            <value>
            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>
            </value>
        </member>
        <member name="P:log4net.helpers.EmptyCollection.SyncRoot">
            <summary>
            gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>
            </summary>
            <value>
            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>
            </value>
        </member>
        <member name="T:log4net.helpers.FormattingInfo">
            <summary>
            FormattingInfo instances contain the information obtained when parsing
            formatting modifiers in conversion modifiers.
            </summary>
        </member>
        <member name="M:log4net.helpers.FormattingInfo.Reset">
            <summary>
            Set back to default values
            </summary>
        </member>
        <member name="M:log4net.helpers.FormattingInfo.Dump">
            <summary>
            Dump debug info
            </summary>
        </member>
        <member name="P:log4net.helpers.FormattingInfo.Min">
            <summary>
            Minimum value
            </summary>
        </member>
        <member name="P:log4net.helpers.FormattingInfo.Max">
            <summary>
            Maximum value
            </summary>
        </member>
        <member name="P:log4net.helpers.FormattingInfo.LeftAlign">
            <summary>
            Flag indicating left align
            </summary>
        </member>
        <member name="T:log4net.helpers.LogLog">
            <summary>
            This class used to output log statements from within the log4net assembly.
            </summary>
            <remarks>
            <para>log4net components cannot make log4net logging calls. However, it is
            sometimes useful for the user to learn about what log4net is
            doing. You can enable log4net internal logging by setting the debug
            flag in the configurator.</para>

            <para>All log4net internal debug calls go to <see cref="P:System.Console.Out"/>
            where as internal error messages are sent to <see cref="P:System.Console.Error"/>.
            All internal messages are prepended with the string "log4net: ".</para>
            </remarks>
        </member>
        <member name="F:log4net.helpers.LogLog.s_debugEnabled">
            <summary>
             Default debug level
            </summary>
        </member>
        <member name="F:log4net.helpers.LogLog.s_quietMode">
            <summary>
            In quietMode not even errors generate any output.
            </summary>
        </member>
        <member name="M:log4net.helpers.LogLog.#cctor">
            <summary>
            Static constructor
            </summary>
            <remarks>
            <para>Initialises logging by reading config file</para>

            <para>The <c>log4net.Internal.Debug</c> ApplicationSetting
            controls internal debugging. This setting should be set
            to <c>true</c> to enable debugging.</para>

            <para>The <c>log4net.Internal.Quiet</c> ApplicationSetting
            supresses all internal logging including error messages.
            This setting should be set to <c>true</c> to enable message
            supression.</para>
            </remarks>
        </member>
        <member name="M:log4net.helpers.LogLog.#ctor">
            <summary>
            Prevent instance objects
            </summary>
        </member>
        <member name="M:log4net.helpers.LogLog.SetInternalDebugging(System.Boolean)">
            <summary>
            Allows to enable/disable log4net internal logging.
            </summary>
            <param name="enabled">set to true to enable internal debugging</param>
            <remarks>
            <para>When set to true will cause internal debug
            level logging to be displayed.</para>

            <para>This value can be set by setting the app settings
            option <c>log4net.Internal.Debug</c> in the config file.</para>

            <para>The default value is false, i.e. debugging is
            disabled.</para>
            </remarks>
            <example>
            Enabeling internal debugging using the config file:
            <code>
            <configuration>
                <appSettings>
                    <add key="log4net.Internal.Debug" value="true" />
                </appSettings>
            </configuration>
            </code>
            </example>
        </member>
        <member name="M:log4net.helpers.LogLog.SetQuietMode(System.Boolean)">
            <summary>
            In quite mode LogLog generates strictly no output, not even for errors.
            </summary>
            <param name="quietMode">Set to true to supress all internal logging</param>
            <remarks>
            <para>When set to true will cause internal logging at all
            levels to be suppressed. This means that no warning or error
            reports will be logged. This option overrides the <see cref="M:log4net.helpers.LogLog.SetInternalDebugging(System.Boolean)"/>
            setting and disables all debug also.</para>

            <para>This value can be set by setting the app settings
            option <c>log4net.Internal.Quiet</c> in the config file.</para>

            <para>The default value is false, i.e. internal logging is not
            disabled.</para>
            </remarks>
            <example>
            Supressing internal logging using the config file:
            <code>
            <configuration>
                <appSettings>
                    <add key="log4net.Internal.Quiet" value="true" />
                </appSettings>
            </configuration>
            </code>
            </example>
        </member>
        <member name="M:log4net.helpers.LogLog.EmitOutLine(System.String)">
            <summary>
            Single method that writes output the the standard
            output stream.  Use Console.Out for console output,
            and Trace for OutputDebugString output.
            </summary>
            <param name="msg">the message to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.EmitErrorLine(System.String)">
            <summary>
            Single method that writes output the the standard
            error stream.  Use Console.Error for console output,
            and Trace for OutputDebugString output.
            </summary>
            <param name="msg">the message to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.Debug(System.String)">
            <summary>
            This method is used to output log4net internal debug
            statements. Output goes to <see cref="P:System.Console.Out"/>.
            </summary>
            <param name="msg">the message to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.Debug(System.String,System.Exception)">
            <summary>
            This method is used to output log4net internal debug
            statements. Output goes to <see cref="P:System.Console.Out"/>.
            </summary>
            <param name="msg">the message to log</param>
            <param name="t">an exception to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.Error(System.String)">
            <summary>
            This method is used to output log4net internal error
            statements. There is no way to disable error statements.
            Output goes to <see cref="P:System.Console.Error"/>.
            </summary>
            <param name="msg">the message to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.Error(System.String,System.Exception)">
            <summary>
            This method is used to output log4net internal error
            statements. There is no way to disable error statements.
            Output goes to <see cref="P:System.Console.Error"/>.
            </summary>
            <param name="msg">the message to log</param>
            <param name="t">an exception to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.Warn(System.String)">
            <summary>
            This method is used to output log4net internal warning
            statements. There is no way to disable warning statements.
            Output goes to <see cref="P:System.Console.Error"/>.
            </summary>
            <param name="msg">the message to log</param>
        </member>
        <member name="M:log4net.helpers.LogLog.Warn(System.String,System.Exception)">
            <summary>
            This method is used to output log4net internal warnings. There is
            no way to disable warning statements.  Output goes to
            <see cref="P:System.Console.Error"/>.
            </summary>
            <param name="msg">the message to log</param>
            <param name="t">an exception to log</param>
        </member>
        <member name="T:log4net.helpers.NullEnumerator">
            <summary>
            An allways empty <see cref="T:System.Collections.IEnumerator"/>.
            </summary>
        </member>
        <member name="F:log4net.helpers.NullEnumerator.s_instance">
            <summary>
            The singleton instance of the null enumerator
            </summary>
        </member>
        <member name="M:log4net.helpers.NullEnumerator.#ctor">
            <summary>
            Private constructor to enforce the singleton pattern
            </summary>
        </member>
        <member name="M:log4net.helpers.NullEnumerator.MoveNext">
            <summary>
            Test if the enumerator can advance, if so advance
            </summary>
            <remarks>
            Always returns false as the NullEnumerator cannot advance
            </remarks>
            <returns>always false</returns>
        </member>
        <member name="M:log4net.helpers.NullEnumerator.Reset">
            <summary>
            Reset the enumerator back to the start
            </summary>
        </member>
        <member name="P:log4net.helpers.NullEnumerator.Instance">
            <summary>
            Get the singleton instance of the null enumerator
            </summary>
            <returns>get the instance of the null enumerator</returns>
        </member>
        <member name="P:log4net.helpers.NullEnumerator.Current">
            <summary>
            Gets the current object from the enumerator
            </summary>
            <remarks>
            This throws an exception because the NullEnumerator
            never has a current value.
            </remarks>
        </member>
        <member name="T:log4net.helpers.OnlyOnceErrorHandler">
            <summary>
            The <see cref="T:log4net.helpers.OnlyOnceErrorHandler"/> implements log4net's default
            error handling policy which consists of emitting a message for the
            first error in an appender and ignoring all following errors.
            </summary>
            <remarks>
            <para>The error message is printed on <see cref="P:System.Console.Error"/>. </para>

            <para>This policy aims at protecting an otherwise working application
            from being flooded with error messages when logging fails.</para>
            </remarks>
        </member>
        <member name="T:log4net.spi.IErrorHandler">
            <summary>
            Appenders may delegate their error handling to ErrorHandlers.
            </summary>
            <remarks>
            Error handling is a particularly tedious to get right because by
            definition errors are hard to predict and to reproduce.
            </remarks>
        </member>
        <member name="M:log4net.spi.IErrorHandler.Error(System.String,System.Exception,log4net.spi.ErrorCodes)">
            <summary>
            This method should handle the error. Information about the error
            condition is passed a parameter.
            </summary>
            <param name="message">The message assoicated with the error</param>
            <param name="e">The Exption that was thrown when the error occured</param>
            <param name="errorCode">The error code associated with the error</param>
        </member>
        <member name="M:log4net.spi.IErrorHandler.Error(System.String,System.Exception)">
            <summary>
            This method prints the error message passed as a parameter.
            </summary>
            <param name="message">The message assoicated with the error</param>
            <param name="e">The Exption that was thrown when the error occured</param>
        </member>
        <member name="M:log4net.spi.IErrorHandler.Error(System.String)">
            <summary>
            This method prints the error message passed as a parameter.
            </summary>
            <param name="message">The message assoicated with the error</param>
        </member>
        <member name="F:log4net.helpers.OnlyOnceErrorHandler.m_firstTime">
            <summary>
            Flag to indicate if it is the first error
            </summary>
        </member>
        <member name="F:log4net.helpers.OnlyOnceErrorHandler.m_prefix">
            <summary>
            String to prefix each message with
            </summary>
        </member>
        <member name="M:log4net.helpers.OnlyOnceErrorHandler.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.helpers.OnlyOnceErrorHandler.#ctor(System.String)">
            <summary>
            Constructor with specified prefix
            </summary>
            <param name="prefix">the prefix to use for each message</param>
        </member>
        <member name="M:log4net.helpers.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.spi.ErrorCodes)">
            <summary>
            Prints the message and the stack trace of the exception on <see cref="P:System.Console.Error"/>
            </summary>
            <param name="message">the error message</param>
            <param name="e">the exception</param>
            <param name="errorCode">the internal error code</param>
        </member>
        <member name="M:log4net.helpers.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
            <summary>
            Prints the message and the stack trace of the exception on <see cref="P:System.Console.Error"/>
            </summary>
            <param name="message">the error message</param>
            <param name="e">the exception</param>
        </member>
        <member name="M:log4net.helpers.OnlyOnceErrorHandler.Error(System.String)">
            <summary>
            Print a the error message passed as parameter on <see cref="P:System.Console.Error"/>.
            </summary>
            <param name="message">the error message</param>
        </member>
        <member name="T:log4net.helpers.OptionConverter">
            <summary>
            A convenience class to convert property values to specific types.
            </summary>
        </member>
        <member name="M:log4net.helpers.OptionConverter.#ctor">
            <summary>
            Private constructor to prevent instances
            </summary>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ConcatanateArrays(System.String[],System.String[])">
            <summary>
            Concatenates two string arrays
            </summary>
            <param name="l">left array</param>
            <param name="r">right array</param>
            <returns>array containg left and right arrays</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ConcatanateArrays(System.Array,System.Array)">
            <summary>
            Concatenates two arrays
            </summary>
            <param name="l">left array</param>
            <param name="r">right array</param>
            <returns>array containg left and right arrays</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ConvertSpecialChars(System.String)">
            <summary>
            Converts string escape chars back to their correct values
            </summary>
            <param name="s">string to convert</param>
            <returns>converted result</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ToBoolean(System.String,System.Boolean)">
            <summary>
            Convert a string to a bool value
            </summary>
            <remarks>
            If <paramref name="argValue"/> is "true", then <c>true</c> is returned.
            If <paramref name="argValue"/> is "false", then <c>true</c> is returned.
            Otherwise, <paramref name="defaultValue"/> is returned.
            </remarks>
            <param name="argValue">string to convert</param>
            <param name="defaultValue">the default value</param>
            <returns>true or false</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ToInt(System.String,System.Int32)">
            <summary>
            Convert a string to an integer
            </summary>
            <param name="argValue">string to convert</param>
            <param name="defaultValue">default value</param>
            <returns>the int value of the string parsed</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ToLevel(System.String,log4net.spi.Level)">
            <summary>
            Converts a standard or custom level to a Level object.
            </summary>
            <remarks>
            If <paramref name="argValue"/> is of form
            "level#classname", then the specified class' toLevel method
            is called to process the specified level string; if no '#'
            character is present, then the default <see cref="T:log4net.spi.Level"/>
            class is used to process the level value.

            <para>If any error occurs while converting the value to a level,
            the dflt value (which may be null) is returned.</para>

            <para>Case of value is unimportant for the level, but is significant
            for any class name part present.</para>
            </remarks>
            <param name="argValue"></param>
            <param name="defaultValue"></param>
            <returns>The Level object</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ToFileSize(System.String,System.Int64)">
            <summary>
            Parse a file size into a number
            </summary>
            <remarks>
            Parses a file size of the form: number[KB|MB|GB] into a
            long value. It is scaled with the appropriate multiplier.
            </remarks>
            <param name="argValue">string to parse</param>
            <param name="defaultValue">default value</param>
            <returns>the value of the string parsed to a long</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.ConvertStringTo(System.Type,System.String)">
            <summary>
            Convert a string to a object
            </summary>
            <param name="target">the target type to convert to</param>
            <param name="txt">the string to convert to an object</param>
            <returns>the object converted from a string, or null if not able</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.FindAndSubst(System.String,System.Collections.IDictionary)">
            <summary>
            Find the value corresponding to <paramref name="key"/> in
            <paramref name="props"/>. Then perform variable substitution
            on the found value.
            </summary>
            <param name="key">the key to lookup</param>
            <param name="props">the association to use for lookups</param>
            <returns>the substituted result</returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">
            <summary>
            Instantiate an object given a class name
            </summary>
            <remarks>
            Instantiate an object given a class name. Check that the
            <paramref name="className"/> is a subclass of
            <paramref name="superClass"/>. If that test fails or the object could
            not be instantiated, then <paramref name="defaultValue"/> is returned.
            </remarks>
            <param name="className">The fully qualified class name of the object to instantiate</param>
            <param name="superClass">The class to which the new object should belong</param>
            <param name="defaultValue">The object to return in case of non-fulfillment</param>
            <returns></returns>
        </member>
        <member name="M:log4net.helpers.OptionConverter.SubstVars(System.String,System.Collections.IDictionary)">
            <summary>
            Perform variable substitution in string <paramref name="val"/> from the values of keys found in <paramref name="props"/>.
            </summary>
            <remarks>
            <para>The variable substitution delimeters are <b>${</b> and <b>}</b>.</para>

            <para>For example, if props contains "key=value", then the call</para>
            <code>
            string s = OptionConverter.substituteVars("Value of key is ${key}.");
            </code>

            will set the variable <c>s</c> to "Value of key is value.".

            <para>If no value could be found for the specified key,
            then substitution defaults to the empty string.</para>

            <para>For example, if system propeties contains no value for the key
            "inexistentKey", then the call</para>

            <code>
            string s = OptionConverter.subsVars("Value of inexistentKey is [${inexistentKey}]");
            </code>
            will set <s>s</s> to "Value of inexistentKey is []"

            <para>An Exception is thrown if
            <paramref name="value"/> contains a start delimeter "${" which is not
            balanced by a stop delimeter "}". </para>
            </remarks>
            <param name="value">The string on which variable substitution is performed</param>
            <param name="props">the dictionary to use to lookup variables</param>
            <returns>the result of the substitutions</returns>
        </member>
        <member name="T:log4net.helpers.PatternConverter">
            <summary>
            PatternConverter is an abtract class that provides the
            formatting functionality that derived classes need.
            </summary>
            <remarks>
            Conversion specifiers in a conversion patterns are parsed to
            individual PatternConverters. Each of which is responsible for
            converting a logging event in a converter specific manner.
            </remarks>
        </member>
        <member name="M:log4net.helpers.PatternConverter.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternConverter.#ctor(log4net.helpers.FormattingInfo)">
            <summary>
            Construct the pattern converter using a formatting info object
            </summary>
            <param name="fi">the formatting info object to use</param>
        </member>
        <member name="M:log4net.helpers.PatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            Derived pattern converters must override this method in order to
            convert conversion specifiers in the correct way.
            </summary>
            <param name="loggingEvent"></param>
            <returns></returns>
        </member>
        <member name="M:log4net.helpers.PatternConverter.Format(System.Text.StringBuilder,log4net.spi.LoggingEvent)">
            <summary>
            A template method for formatting in a converter specific way.
            </summary>
            <param name="sbuf"></param>
            <param name="e"></param>
        </member>
        <member name="M:log4net.helpers.PatternConverter.SpacePad(System.Text.StringBuilder,System.Int32)">
            <summary>
            Fast space padding method.
            </summary>
            <param name="sbuf"></param>
            <param name="length"></param>
        </member>
        <member name="P:log4net.helpers.PatternConverter.Next">
            <summary>
            the next patter converter in the chain
            </summary>
        </member>
        <member name="T:log4net.helpers.PatternParser">
            <summary>
            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class
            is delegated to the PatternParser class.
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_currentLiteral">
            <summary>
            the literal being parsed
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_patternLength">
            <summary>
            the total length of the pattern
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_index">
            <summary>
            the current index into the pattern
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_head">
            <summary>
            The first pattern converter in the chain
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_tail">
            <summary>
             the last pattern converter in the chain
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_formattingInfo">
            <summary>
            the formatting info object
            </summary>
        </member>
        <member name="F:log4net.helpers.PatternParser.m_pattern">
            <summary>
            The pattern
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.#ctor(System.String)">
            <summary>
            Create a pattern parse for a specific pattern string
            </summary>
            <param name="pattern">the parrern to parse</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.AddToList(log4net.helpers.PatternConverter)">
            <summary>
            Internal method to add a pattern converter to the chain
            </summary>
            <param name="pc">the converter to add</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.ExtractOption">
            <summary>
            Internal method to extract the option from the pattern at the current index
            </summary>
            <remarks>
            The option is the section of the pattern between '{' and '}'.
            This function returns the option if the current index of the
            parse is at the start of the option, otherwise null is returned.
            </remarks>
            <returns>returns the option or null</returns>
        </member>
        <member name="M:log4net.helpers.PatternParser.ExtractPrecisionOption">
            <summary>
            The option is expected to be in decimal and positive. In case of error, zero is returned.
            </summary>
            <returns>the option as a number</returns>
        </member>
        <member name="M:log4net.helpers.PatternParser.Parse">
            <summary>
            Parse the pattern into a chain of pattern converters
            </summary>
            <returns>the head of a chain of pattern converters</returns>
        </member>
        <member name="M:log4net.helpers.PatternParser.FinalizeConverter(System.Char)">
            <summary>
            Internal method that works on a single option in the
            pattern
            </summary>
            <param name="c">the option specifier</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.AddConverter(log4net.helpers.PatternConverter)">
            <summary>
            Internal method to add a pattern converter
            </summary>
            <remarks>
            Resets the internal state of the parser as well as adding the pattern converter to the chain
            </remarks>
            <param name="pc">the pattern converter to add</param>
        </member>
        <member name="T:log4net.helpers.PatternParser.BasicPatternConverter">
            <summary>
            Basic pattern converter
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.BasicPatternConverter.#ctor(log4net.helpers.FormattingInfo,System.Int32)">
            <summary>
            Construct the pattern converter with formatting info and type
            </summary>
            <param name="formattingInfo">the formatting info</param>
            <param name="type">the type of pattern</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.BasicPatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            To the conversion
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the result of converting the pattern</returns>
        </member>
        <member name="M:log4net.helpers.PatternParser.BasicPatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
            <summary>
            Internal method to get the time difference between two DateTime objects
            </summary>
            <param name="start">start time</param>
            <param name="end">end time</param>
            <returns>the time difference in milliseconds</returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.LiteralPatternConverter">
            <summary>
            Pattern converter for literal instances in the pattern
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.LiteralPatternConverter.#ctor(System.String)">
            <summary>
            Constructor, takes the literal string
            </summary>
            <param name="strValue"></param>
        </member>
        <member name="M:log4net.helpers.PatternParser.LiteralPatternConverter.Format(System.Text.StringBuilder,log4net.spi.LoggingEvent)">
            <summary>
            Override the formatting behaviour to ignore the FormattingInfo
            because we have a literal instead.
            </summary>
            <param name="sbuf">the builder to write to</param>
            <param name="loggingEvent">the event being logged</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.LiteralPatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            Convert this pattern into the rendered message
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the literal</returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.MDCPatternConverter">
            <summary>
            Mapped Diagnostic pattern converter
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.MDCPatternConverter.#ctor(log4net.helpers.FormattingInfo,System.String)">
            <summary>
            Construct the pattern converter with formatting info and MDC key
            </summary>
            <param name="formattingInfo">the formatting info</param>
            <param name="key">the MDC key to emmit</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.MDCPatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            To the conversion
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the result of converting the pattern</returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.DatePatternConverter">
            <summary>
            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the date
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.DatePatternConverter.#ctor(log4net.helpers.FormattingInfo,log4net.DateFormatter.IDateFormatter)">
            <summary>
            Construct the converter with formatting info and a
            <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the date
            </summary>
            <param name="formattingInfo">the formatting info</param>
            <param name="df">the date formatter</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.DatePatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            Convert the pattern into the rendered message
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns></returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.LocationPatternConverter">
            <summary>
            Converter to include event location information
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.LocationPatternConverter.#ctor(log4net.helpers.FormattingInfo,System.Int32)">
            <summary>
            Construct the converter with formatting information and
            the type of location information required.
            </summary>
            <param name="formattingInfo"></param>
            <param name="type"></param>
        </member>
        <member name="M:log4net.helpers.PatternParser.LocationPatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            Convert the pattern to the rendered message
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the relevent location information</returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.NamedPatternConverter">
            <summary>
            Converter to deal with '.' separated strings
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.NamedPatternConverter.#ctor(log4net.helpers.FormattingInfo,System.Int32)">
            <summary>
            Construct a converter with formatting info and a precision
            argument. The precision is the number of '.' separated sections
            to return, starting from the end of the string and working
            towards to the start.
            </summary>
            <param name="formattingInfo">the formatting info</param>
            <param name="precision">the precision</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.NamedPatternConverter.GetFullyQualifiedName(log4net.spi.LoggingEvent)">
            <summary>
            Overriden by subclasses to get the fully qualified name before the
            precision is applied to it.
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the fully qualified name</returns>
        </member>
        <member name="M:log4net.helpers.PatternParser.NamedPatternConverter.Convert(log4net.spi.LoggingEvent)">
            <summary>
            Convert the pattern to the rendered message
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the precision of the fully qualified name specified</returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.ClassNamePatternConverter">
            <summary>
            Pattern converter for the class name
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.ClassNamePatternConverter.#ctor(log4net.helpers.FormattingInfo,System.Int32)">
            <summary>
            Constructor
            </summary>
            <param name="formattingInfo">formatting info</param>
            <param name="precision">namespace depth precision</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.ClassNamePatternConverter.GetFullyQualifiedName(log4net.spi.LoggingEvent)">
            <summary>
            Gets the fully qualified name of the class
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the class name</returns>
        </member>
        <member name="T:log4net.helpers.PatternParser.LoggerPatternConverter">
            <summary>
            Converter for logger name
            </summary>
        </member>
        <member name="M:log4net.helpers.PatternParser.LoggerPatternConverter.#ctor(log4net.helpers.FormattingInfo,System.Int32)">
            <summary>
            Constructor
            </summary>
            <param name="formattingInfo">formatting info</param>
            <param name="precision">logger hierarchy depth precision</param>
        </member>
        <member name="M:log4net.helpers.PatternParser.LoggerPatternConverter.GetFullyQualifiedName(log4net.spi.LoggingEvent)">
            <summary>
            Gets the fully qualified name of the logger
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the logger name</returns>
        </member>
        <member name="T:log4net.helpers.Transform">
            <summary>
            Utility class for transforming strings
            </summary>
        </member>
        <member name="M:log4net.helpers.Transform.#ctor">
            <summary>
            Private constructor to prevent instances
            </summary>
        </member>
        <member name="M:log4net.helpers.Transform.EscapeXMLTags(System.String)">
            <summary>
            Escapes XML chars in a string
            </summary>
            <param name="input">string that may contain XML tag chars</param>
            <returns>escaped string</returns>
            <remarks>
            This method takes a string which may contain XML tags (ie, <b>, <table>,
            etc) and converts the '<' and '>' characters to their XML escape
            sequences.
            </remarks>
        </member>
        <member name="M:log4net.helpers.Transform.AppendEscapingCDATA(System.Text.StringBuilder,System.String)">
            <summary>
            Ensures that embeded CDEnd strings (]]>) are handled properly tag text.
            </summary>
            <param name="buf">holding the XML data to this point.  The
            initial CDStart (<![CDATA[) and final CDEnd (]]>) of the CDATA
            section are the responsibility of the calling method</param>
            <param name="str">The String that is inserted into an existing CDATA Section within buf</param>
        </member>
        <member name="M:log4net.helpers.Transform.EscapeInCDATA(System.String)">
            <summary>
            Escape a string by placing it in a CDATA section
            </summary>
            <param name="str">the string that needs to be escaped</param>
            <returns>A string which is a CDATA section containing the argument string</returns>
        </member>
        <member name="T:log4net.Layout.ILayout">
            <summary>
            Interface implemented by layout objects
            </summary>
            <remarks>
            <para>An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.spi.LoggingEvent"/>
            as a string. The <see cref="M:log4net.Layout.ILayout.Format(log4net.spi.LoggingEvent)"/> method is called by an
            appender to transform the <see cref="T:log4net.spi.LoggingEvent"/> into a string.</para>

            <para>The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
            text that is appender before any events and after all the events respectivly.</para>
            </remarks>
        </member>
        <member name="M:log4net.Layout.ILayout.Format(log4net.spi.LoggingEvent)">
            <summary>
            Implement this method to create your own layout format.
            </summary>
            <param name="loggingEvent">The event to format</param>
            <returns>returns the formatted event</returns>
            <remarks>
            <para>This method is called by an appender to format
            the <paramref name="loggingEvent"/> as a string.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.ILayout.ContentType">
            <summary>
            The content type output by this layout.
            </summary>
            <value>The content type</value>
            <remarks>
            <para>The content type output by this layout.</para>
            <para>This is a MIME type e.g. <c>"text/plain"</c>.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.ILayout.Header">
            <summary>
            The header for the layout format.
            </summary>
            <value>the layout header</value>
            <remarks>
            <para>The Header text will be appended before any logging events
            are formatted and appended.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.ILayout.Footer">
            <summary>
            The footer for the layout format.
            </summary>
            <value>the layout footer</value>
            <remarks>
            <para>The Footer text will be appended after all the logging events
            have been formatted and appended.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.ILayout.IgnoresException">
            <summary>
            Flag indicating if this layout handle exceptions
            </summary>
            <value><c>false</c> if this layout handles exceptions</value>
            <remarks>
            <para>If this layout handles the exception object contained within
            <see cref="T:log4net.spi.LoggingEvent"/>, then the layout should return
            <c>false</c>. Otherwise, if the layout ignores the exception
            object, then the layout should return <c>true</c>.</para>
            </remarks>
        </member>
        <member name="T:log4net.Layout.LayoutSkeleton">
            <summary>
            Extend this abstract class to create your own log layout format.
            </summary>
            <remarks>
            <para>This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
            interface. Most layout objects should extend this class.</para>
            </remarks>
        </member>
        <member name="F:log4net.Layout.LayoutSkeleton.m_header">
            <summary>
            The header text
            </summary>
            <remarks>
            <para>See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.</para>
            </remarks>
        </member>
        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
            <summary>
            The footer text
            </summary>
            <remarks>
            <para>See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.</para>
            </remarks>
        </member>
        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
            <summary>
            Emptry default constructor
            </summary>
            <remarks>
            Emptry default constructor
            </remarks>
        </member>
        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
            <summary>
            Activate the options that were previously set with calls to option setters.
            </summary>
            <remarks>
            <para>This allows defered activiation of the options once all
            options have been set. This is required for components which have
            related options that remain ambigous until all are set.</para>

            <para>This method must be implemented by the subclass.</para>
            </remarks>
        </member>
        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.spi.LoggingEvent)">
            <summary>
            Implement this method to create your own layout format.
            </summary>
            <param name="loggingEvent">The event to format</param>
            <returns>returns the formatted event</returns>
            <remarks>
            <para>This method is called by an appender to format
            the <paramref name="loggingEvent"/> as a string.</para>

            <para>This method must be implemented by the subclass.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
            <summary>
            The content type output by this layout.
            </summary>
            <value>The content type is <c>"text/plain"</c></value>
            <remarks>
            <para>The content type output by this layout.</para>
            <para>This base class uses the value <c>"text/plain"</c>.
            To change this value a subclass must override this
            property.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.LayoutSkeleton.Header">
            <summary>
            The header for the layout format.
            </summary>
            <value>the layout header</value>
            <remarks>
            <para>The Header text will be appended before any logging events
            are formatted and appended.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.LayoutSkeleton.Footer">
            <summary>
            The footer for the layout format.
            </summary>
            <value>the layout footer</value>
            <remarks>
            <para>The Footer text will be appended after all the logging events
            have been formatted and appended.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
            <summary>
            Flag indicating if this layout handle exceptions
            </summary>
            <value><c>false</c> if this layout handles exceptions</value>
            <remarks>
            <para>If this layout handles the exception object contained within
            <see cref="T:log4net.spi.LoggingEvent"/>, then the layout should return
            <c>false</c>. Otherwise, if the layout ignores the exception
            object, then the layout should return <c>true</c>.</para>

            <para>This method must be implemented by the subclass.</para>
            </remarks>
        </member>
        <member name="T:log4net.Layout.PatternLayout">
            <summary>
            A flexible layout configurable with pattern string.
            </summary>
            <remarks>
            <para>The goal of this class is to <see cref="M:log4net.Layout.PatternLayout.Format(log4net.spi.LoggingEvent)"/> a
            <see cref="T:log4net.spi.LoggingEvent"/> and return the results as a string. The results
            depend on the <i>conversion pattern</i>.</para>

            <para>The conversion pattern is closely related to the conversion
            pattern of the printf function in C. A conversion pattern is
            composed of literal text and format control expressions called
            <i>conversion specifiers</i>.</para>

            <para><i>You are free to insert any literal text within the conversion
            pattern.</i></para>

            <para>Each conversion specifier starts with a percent sign (%) and is
            followed by optional <i>format modifiers</i> and a <i>conversion
            character</i>. The conversion character specifies the type of
            data, e.g. logger, level, date, thread name. The format
            modifiers control such things as field width, padding, left and
            right justification. The following is a simple example.</para>

            <para>Let the conversion pattern be <b>"%-5p [%t]: %m%n"</b> and assume
            that the log4net environment was set to use a PatternLayout. Then the
            statements</para>
            <code>
            Logger root = Logger.getRoot();
            root.debug("Message 1");
            root.warn("Message 2");
            </code>
            <para>would yield the output</para>
            <code>
            DEBUG [main]: Message 1
            WARN  [main]: Message 2
            </code>

            <para>Note that there is no explicit separator between text and
            conversion specifiers. The pattern parser knows when it has reached
            the end of a conversion specifier when it reads a conversion
            character. In the example above the conversion specifier
            <b>%-5p</b> means the level of the logging event should be left
            justified to a width of five characters.</para>

            The recognized conversion characters are

            <table border="1" CELLPADDING="8">
            <th>Conversion Character</th>
            <th>Effect</th>

            <tr>
                <td align="center"><b>c</b></td>

                <td>
                <para>Used to output the logger of the logging event. The
                logger conversion specifier can be optionally followed by
                <i>precision specifier</i>, that is a decimal constant in
                brackets.</para>

                <para>If a precision specifier is given, then only the corresponding
                number of right most components of the logger name will be
                printed. By default the logger name is printed in full.</para>

                <para>For example, for the logger name "a.b.c" the pattern
                <b>%c{2}</b> will output "b.c".</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>C</b></td>

                <td>
                <para>Used to output the fully qualified class name of the caller
                issuing the logging request. This conversion specifier
                can be optionally followed by <i>precision specifier</i>, that
                is a decimal constant in brackets.</para>

                <para>If a precision specifier is given, then only the corresponding
                number of right most components of the class name will be
                printed. By default the class name is output in fully qualified form.</para>

                <para>For example, for the class name "org.apache.xyz.SomeClass", the
                pattern <b>%C{1}</b> will output "SomeClass".</para>

                <para><b>WARNING</b> Generating the caller class information is
                slow. Thus, it's use should be avoided unless execution speed is
                not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>d</b></td>

                <td>
                <para>Used to output the date of
                the logging event. The date conversion specifier may be
                followed by a <i>date format specifier</i> enclosed between
                braces. For example, <b>%d{HH:mm:ss,SSS}</b> or
                <b>%d{dd MMM yyyy HH:mm:ss,SSS}</b>.  If no
                date format specifier is given then ISO8601 format is
                assumed (<see cref="T:log4net.DateFormatter.ISO8601DateFormatter"/>).</para>

                <para>The date format specifier admits the same syntax as the
                time pattern string of the <see cref="M:System.DateTime.ToString"/>.</para>

                <para>For better results it is recommended to use the log4net date
                formatters. These can be specified using one of the strings
                "ABSOLUTE", "DATE" and "ISO8601" for specifying
                <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>,
                <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively
                <see cref="T:log4net.DateFormatter.ISO8601DateFormatter"/>. For example,
                <b>%d{ISO8601}</b> or <b>%d{ABSOLUTE}</b>.</para>

                <para>These dedicated date formatters perform significantly
                better than <see cref="M:System.DateTime.ToString(System.String)"/>.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>F</b></td>

                <td>
                <para>Used to output the file name where the logging request was
                issued.</para>

                <para><b>WARNING</b> Generating caller location information is
                extremely slow. It's use should be avoided unless execution speed
                is not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>l</b></td>

                <td>
                <para>Used to output location information of the caller which generated
                the logging event.</para>

                <para>The location information depends on the JVM implementation but
                usually consists of the fully qualified name of the calling
                method followed by the callers source the file name and line
                number between parentheses.</para>

                <para>The location information can be very useful. However, it's
                generation is <b>extremely</b> slow. It's use should be avoided
                unless execution speed is not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>L</b></td>

                <td>
                <para>Used to output the line number from where the logging request
                was issued.</para>

                <para><b>WARNING</b> Generating caller location information is
                extremely slow. It's use should be avoided unless execution speed
                is not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>m</b></td>

                <td>
                <para>Used to output the application supplied message associated with
                the logging event.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>M</b></td>

                <td>
                <para>Used to output the method name where the logging request was
                issued.</para>

                <para><b>WARNING</b> Generating caller location information is
                extremely slow. It's use should be avoided unless execution speed
                is not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>n</b></td>

                <td>
                <para>Outputs the platform dependent line separator character or
                characters.</para>

                <para>This conversion character offers practically the same
                performance as using non-portable line separator strings such as
                "\n", or "\r\n". Thus, it is the preferred way of specifying a
                line separator.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>p</b></td>

                <td>
                <para>Used to output the level of the logging event.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>r</b></td>

                <td>
                <para>Used to output the number of milliseconds elapsed since the start
                of the application until the creation of the logging event.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>t</b></td>

                <td>
                <para>Used to output the name of the thread that generated the
                logging event.  Uses the thread number if no name is available.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>u</b></td>

                <td>
                <para>Used to output the user name for the currently active user.</para>

                <para><b>WARNING</b> Generating caller information is
                extremely slow. It's use should be avoided unless execution speed
                is not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>W</b></td>

                <td>
                <para>Used to output the WindowsIdentity for the currently
                active user.</para>

                <para><b>WARNING</b> Generating caller WindowsIdentity information is
                extremely slow. It's use should be avoided unless execution speed
                is not an issue.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>x</b></td>

                <td>
                <para>Used to output the NDC (nested diagnostic context) associated
                with the thread that generated the logging event.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>X</b></td>

                <td>
                <para>Used to output the MDC (mapped diagnostic context) associated
                with the thread that generated the logging event. The key to lookup
                must be specified within braces and directly following the
                pattern specifier, e.g. <c>%X{user}</c> would include the value
                from the MDC that is keyed by the string 'user'. Each MDC value
                that is to be included in the log must be specified seperatly.</para>
                </td>
            </tr>

            <tr>
                <td align="center"><b>%</b></td>

                <td>
                <para>The sequence %% outputs a single percent sign.</para>
                </td>
            </tr>

            </table>

            <para>By default the relevant information is output as is. However,
            with the aid of format modifiers it is possible to change the
            minimum field width, the maximum field width and justification.</para>

            <para>The optional format modifier is placed between the percent sign
            and the conversion character.</para>

            <para>The first optional format modifier is the <i>left justification
            flag</i> which is just the minus (-) character. Then comes the
            optional <i>minimum field width</i> modifier. This is a decimal
            constant that represents the minimum number of characters to
            output. If the data item requires fewer characters, it is padded on
            either the left or the right until the minimum width is
            reached. The default is to pad on the left (right justify) but you
            can specify right padding with the left justification flag. The
            padding character is space. If the data item is larger than the
            minimum field width, the field is expanded to accommodate the
            data. The value is never truncated.</para>

            <para>This behavior can be changed using the <i>maximum field
            width</i> modifier which is designated by a period followed by a
            decimal constant. If the data item is longer than the maximum
            field, then the extra characters are removed from the
            <i>beginning</i> of the data item and not from the end. For
            example, it the maximum field width is eight and the data item is
            ten characters long, then the first two characters of the data item
            are dropped. This behavior deviates from the printf function in C
            where truncation is done from the end.</para>

            <para>Below are various format modifier examples for the logger
            conversion specifier.</para>

            <table border="1" cellpadding="8">
                <th>Format modifier</th>
                <th>left justify</th>
                <th>minimum width</th>
                <th>maximum width</th>
                <th>comment</th>

                <tr>
                    <td align="center">%20c</td>
                    <td align="center">false</td>
                    <td align="center">20</td>
                    <td align="center">none</td>
                    <td>
                        <para>Left pad with spaces if the logger name is less than 20
                        characters long.</para>
                    </td>
                </tr>

                <tr>
                    <td align="center">%-20c</td>
                    <td align="center">true</td>
                    <td align="center">20</td>
                    <td align="center">none</td>
                    <td>
                        <para>Right pad with spaces if the logger
                        name is less than 20 characters long.</para>
                    </td>
                </tr>

                <tr>
                    <td align="center">%.30c</td>
                    <td align="center">NA</td>
                    <td align="center">none</td>
                    <td align="center">30</td>
                    <td>
                        <para>Truncate from the beginning if the logger
                        name is longer than 30 characters.</para>
                    </td>
                </tr>

                <tr>
                    <td align="center">%20.30c</td>
                    <td align="center">false</td>
                    <td align="center">20</td>
                    <td align="center">30</td>
                    <td>
                        <para>Left pad with spaces if the logger name is shorter than 20
                        characters. However, if logger name is longer than 30 characters,
                        then truncate from the beginning.</para>
                    </td>
                </tr>

                <tr>
                    <td align="center">%-20.30c</td>
                    <td align="center">true</td>
                    <td align="center">20</td>
                    <td align="center">30</td>
                    <td>
                        <para>Right pad with spaces if the logger name is shorter than 20
                        characters. However, if logger name is longer than 30 characters,
                        then truncate from the beginning.</para>
                    </td>
                </tr>
            </table>
            </remarks>

            <example>
            This is essentially the TTCC layout
            <code><b>%r [%t] %-5p %c %x - %m\n</b></code>
            </example>

            <example>
            Similar to the TTCC layout except that the relative time is
            right padded if less than 6 digits, thread name is right padded if
            less than 15 characters and truncated if longer and the logger
            name is left padded if shorter than 30 characters and truncated if
            longer.
            <code><b>%-6r [%15.15t] %-5p %30.30c %x - %m\n</b></code>
            </example>

        </member>
        <member name="F:log4net.Layout.PatternLayout.DEFAULT_CONVERSION_PATTERN">
            <summary>
            Default pattern string for log output.
            Currently set to the string <b>"%m%n"</b>
            which just prints the application supplied    message.
            </summary>
        </member>
        <member name="F:log4net.Layout.PatternLayout.TTCC_CONVERSION_PATTERN">
            <summary>
            A conversion pattern equivalent to the TTCCCLayout. Current value is <b>%r [%t] %p %c %x - %m%n</b>.
            </summary>
        </member>
        <member name="F:log4net.Layout.PatternLayout.BUF_SIZE">
            <summary>
            Initial buffer size
            </summary>
        </member>
        <member name="F:log4net.Layout.PatternLayout.MAX_CAPACITY">
            <summary>
            Maximum buffer size before it is recycled
            </summary>
        </member>
        <member name="F:log4net.Layout.PatternLayout.m_sbuf">
            <summary>
            output buffer appended to when Format() is invoked
            </summary>
        </member>
        <member name="F:log4net.Layout.PatternLayout.m_pattern">
            <summary>
            the pattern
            </summary>
        </member>
        <member name="F:log4net.Layout.PatternLayout.m_head">
            <summary>
            the head of the pattern converter chain
            </summary>
        </member>
        <member name="M:log4net.Layout.PatternLayout.#ctor">
            <summary>
            Constructs a PatternLayout using the DEFAULT_LAYOUT_PATTERN
            </summary>
            <remarks>
            The default pattern just produces the application supplied message.
            </remarks>
        </member>
        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">
            <summary>
            Constructs a PatternLayout using the supplied conversion pattern
            </summary>
            <param name="pattern">the pattern to use</param>
        </member>
        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">
            <summary>
            Returns PatternParser used to parse the conversion string. Subclasses
            may override this to return a subclass of PatternParser which recognize
            custom conversion characters.
            </summary>
            <param name="pattern">the pattern to parse</param>
            <returns></returns>
        </member>
        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">
            <summary>
            Does not do anything as options become effective immediately.
            </summary>
        </member>
        <member name="M:log4net.Layout.PatternLayout.Format(log4net.spi.LoggingEvent)">
            <summary>
            Produces a formatted string as specified by the conversion pattern.
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the formatted string</returns>
        </member>
        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">
            <summary>
            The <b>ConversionPattern</b> option. This is the string which
            controls formatting and consists of a mix of literal content and
            conversion specifiers.
            </summary>
        </member>
        <member name="P:log4net.Layout.PatternLayout.IgnoresException">
            <summary>
            The PatternLayout does not handle the exception contained within
            LoggingEvents. Thus, it returns <c>true</c>.
            </summary>
        </member>
        <member name="T:log4net.Layout.SimpleLayout">
            <summary>
            A very simple layout
            </summary>
            <remarks>
            SimpleLayout consists of the level of the log statement,
            followed by " - " and then the log message itself. For example,
            <code>
            DEBUG - Hello world
            </code>
            </remarks>
        </member>
        <member name="F:log4net.Layout.SimpleLayout.BUF_SIZE">
            <summary>
            Initial buffer size
            </summary>
        </member>
        <member name="F:log4net.Layout.SimpleLayout.MAX_CAPACITY">
            <summary>
            Maximum buffer size before it is recycled
            </summary>
        </member>
        <member name="F:log4net.Layout.SimpleLayout.m_sbuf">
            <summary>
            output buffer appended to when Format() is invoked
            </summary>
        </member>
        <member name="M:log4net.Layout.SimpleLayout.#ctor">
            <summary>
            Constructs a SimpleLayout
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
            <summary>
            Does not do anything as options become effective immediately.
            </summary>
        </member>
        <member name="M:log4net.Layout.SimpleLayout.Format(log4net.spi.LoggingEvent)">
            <summary>
            Produces a formatted string.
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the formatted string</returns>
        </member>
        <member name="P:log4net.Layout.SimpleLayout.IgnoresException">
            <summary>
            The PatternLayout does not handle the exception contained within
            LoggingEvents. Thus, it returns <c>true</c>.
            </summary>
        </member>
        <member name="T:log4net.Layout.XMLLayout">
            <summary>
            Layout that formats the log events as XML elements
            </summary>
            <remarks>
            The output of the XMLLayout consists of a series of log4net:event
            elements. It does not output a complete well-formed XML file.
            The output is designed to be included as an <em>external entity</em>
            in a separate file to form a correct XML file.
            <para>For example, if <code>abc</code> is the name of the file where
            the XMLLayout ouput goes, then a well-formed XML file would be:</para>

            <code>
            <?xml version="1.0" ?>

            <!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [<!ENTITY data SYSTEM "abc">]>

            <log4net:events version="1.2" xmlns:log4net="http://log4net.sourceforge.net/">
                &data;
            </log4net:events>
            </code>

            <para>This approach enforces the independence of the XMLLayout and the
            appender where it is embedded.</para>

            <para>The <code>version</code> attribute helps components to correctly
            intrepret output generated by XMLLayout. The value of this
            attribute should be "1.2" for relase 1.2 and later.</para>

            <para>
            Alternativly the <c>Header</c> and <c>Footer</c> properties can be
            configured to output the correct XML header, open tag and close tag.
            </para>
            </remarks>
        </member>
        <member name="F:log4net.Layout.XMLLayout.BUF_SIZE">
            <summary>
            Initial buffer size
            </summary>
        </member>
        <member name="F:log4net.Layout.XMLLayout.MAX_CAPACITY">
            <summary>
            Maximum buffer size before it is recycled
            </summary>
        </member>
        <member name="F:log4net.Layout.XMLLayout.m_sbuf">
            <summary>
            output buffer appended to when Format() is invoked
            </summary>
        </member>
        <member name="F:log4net.Layout.XMLLayout.m_locationInfo">
            <summary>
            Flat to indicate if LocationInfo should be included in
            the XML events
            </summary>
        </member>
        <member name="M:log4net.Layout.XMLLayout.#ctor">
            <summary>
            Constructs an XMLLayout
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:log4net.Layout.XMLLayout.#ctor(System.Boolean)">
            <summary>
            Constructs an XMLLayout
            </summary>
            <remarks>
            The <b>LocationInfo</b> option takes a boolean value. By
            default, it is set to false which means there will be no location
            information output by this layout. If the the option is set to
            true, then the file name and line number of the statement
            at the origin of the log statement will be output.

            <para>If you are embedding this layout within an
            <see cref="T:log4net.Appender.SMTPAppender"/>
             then make sure to set the
            <b>LocationInfo</b> option of that appender as well.</para>
            </remarks>
        </member>
        <member name="M:log4net.Layout.XMLLayout.ActivateOptions">
            <summary>
            Does not do anything as options become effective immediately.
            </summary>
        </member>
        <member name="M:log4net.Layout.XMLLayout.Format(log4net.spi.LoggingEvent)">
            <summary>
            Produces a formatted string.
            </summary>
            <param name="loggingEvent">the event being logged</param>
            <returns>the formatted string</returns>
        </member>
        <member name="P:log4net.Layout.XMLLayout.LocationInfo">
            <summary>
            Set to true to include LocationInfo in the XML events
            </summary>
            <value>
            Include LocationInfo in the XML events
            </value>
            <remarks>
            The <b>LocationInfo</b> option takes a boolean value. By
            default, it is set to false which means there will be no location
            information output by this layout. If the the option is set to
            true, then the file name and line number of the statement
            at the origin of the log statement will be output.

            <para>If you are embedding this layout within an
            <see cref="T:log4net.Appender.SMTPAppender"/>
             then make sure to set the
            <b>LocationInfo</b> option of that appender as well.</para>
            </remarks>
        </member>
        <member name="P:log4net.Layout.XMLLayout.ContentType">
            <summary>
            Returns the content type output by this layout.
            As this is the XML layout this returns "text/xml".
            </summary>
            <returns>the content type</returns>
        </member>
        <member name="P:log4net.Layout.XMLLayout.IgnoresException">
            <summary>
            The PatternLayout does not handle the exception contained within
            LoggingEvents. Thus, it returns <c>true</c>.
            </summary>
        </member>
        <member name="T:log4net.ObjectRenderer.DefaultRenderer">
            <summary>
            The default Renderer renders objects by calling their <see cref="M:System.Object.ToString"/> method.
            </summary>
            <remarks>
            <para>The default renderer supports rendering objects to strings as follows:</para>

            <list type="table">
                <listheader>
                    <term>Value</term>
                    <description>Rendered String</description>
                </listheader>
                <item>
                    <term><c>null</c></term>
                    <description><para>"(null)"</para></description>
                </item>
                <item>
                    <term><see cref="T:System.Array"/></term>
                    <description>
                    <para>For a one dimentional array this is the
                    array type name, an open brace, followed by a comma
                    seperated list of the elements (using the appropriate
                    renderer), followed by a close brace. For example:
                    <c>int[] {1, 2, 3}</c>.</para>
                    <para>If the array is not one dimentional the
                    <c>Array.ToString()</c> is returned.</para>
                    </description>
                </item>
                <item>
                    <term><see cref="T:System.Exception"/></term>
                    <description>
                    <para>Renders the exception type, message
                    and stack trace. Any nested exception is also rendered.</para>
                    </description>
                </item>
                <item>
                    <term>other</term>
                    <description>
                    <para><c>Object.ToString()</c></para>
                    </description>
                </item>
            </list>

            <para>The <see cref="T:log4net.ObjectRenderer.DefaultRenderer"/> serves as a good base class
            for renderers that need to provide special handeling of exception
            types. The <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderException(log4net.ObjectRenderer.RendererMap,System.Exception)"/> method is used to render
            the exception and its nested exceptions, however the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderExceptionMessage(log4net.ObjectRenderer.RendererMap,System.Exception)"/>
            method is called just to render the exceptions message. This method
            can be overridden is a subclass to provide additional infromation
            for some exception types. See <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderException(log4net.ObjectRenderer.RendererMap,System.Exception)"/> for
            more information.</para>
            </remarks>
        </member>
        <member name="T:log4net.ObjectRenderer.IObjectRenderer">
            <summary>
            Implement this interface in order to render objects as strings
            </summary>
            <remarks>
            <para>Certain types require special case conversion to
            string form. This conversion is done by an object renderer.
            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>
            interface.</para>
            </remarks>
        </member>
        <member name="M:log4net.ObjectRenderer.IObjectRenderer.DoRender(log4net.ObjectRenderer.RendererMap,System.Object)">
            <summary>
            Render the object <paramref name="obj"/> to a string
            </summary>
            <param name="rendererMap">The map used to lookup renderers</param>
            <param name="obj">The object to render</param>
            <returns>the object rendered as a string</returns>
            <remarks>
            <para>Render the object <paramref name="obj"/> to a
            string.</para>

            <para>The <paramref name="rendererMap"/> parameter is
            provided to lookup and render other objects. This is
            very usefull where <paramref name="obj"/> contains
            nested objects of unknown type. The <see cref="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)"/>
            method can be used to render these objects.</para>
            </remarks>
        </member>
        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">
            <summary>
            Default constructor
            </summary>
            <remarks>
            Default constructor
            </remarks>
        </member>
        <member name="M:log4net.ObjectRenderer.DefaultRenderer.DoRender(log4net.ObjectRenderer.RendererMap,System.Object)">
            <summary>
            Render the object <paramref name="obj"/> to a string
            </summary>
            <param name="rendererMap">The map used to lookup renderers</param>
            <param name="obj">The object to render</param>
            <returns>the object rendered as a string</returns>
            <remarks>
            <para>Render the object <paramref name="obj"/> to a
            string.</para>

            <para>The <paramref name="rendererMap"/> parameter is
            provided to lookup and render other objects. This is
            very usefull where <paramref name="obj"/> contains
            nested objects of unknown type. The <see cref="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)"/>
            method can be used to render these objects.</para>

            <para>The default renderer supports rendering objects to strings as follows:</para>

            <list type="table">
                <listheader>
                    <term>Value</term>
                    <description>Rendered String</description>
                </listheader>
                <item>
                    <term><c>null</c></term>
                    <description>
                    <para>"(null)"</para>
                    </description>
                </item>
                <item>
                    <term><see cref="T:System.Array"/></term>
                    <description>
                    <para>For a one dimentional array this is the
                    array type name, an open brace, followed by a comma
                    seperated list of the elements (using the appropriate
                    renderer), followed by a close brace. For example:
                    <c>int[] {1, 2, 3}</c>.</para>
                    <para>If the array is not one dimentional the
                    <c>Array.ToString()</c> is returned.</para>

                    <para>The <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array)"/> method is called
                    to do the actual array rendering. This method can be
                    overriden in a subclass to provide different array
                    rendering.</para>
                    </description>
                </item>
                <item>
                    <term><see cref="T:System.Exception"/></term>
                    <description>
                    <para>Renders the exception type, message
                    and stack trace. Any nested exception is also rendered.</para>

                    <para>The <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderException(log4net.ObjectRenderer.RendererMap,System.Exception)"/> method is called
                    to do the actual exception rendering. This method can be
                    overriden in a subclass to provide different exception
                    rendering.</para>
                    </description>
                </item>
                <item>
                    <term>other</term>
                    <description>
                    <para><c>Object.ToString()</c></para>
                    </description>
                </item>
            </list>
            </remarks>
        </member>
        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array)">
            <summary>
            Render the array argument into a string
            </summary>
            <param name="rendererMap">The map used to lookup renderers</param>
            <param name="array">the array to render</param>
            <returns>the string representation of the array</returns>
            <remarks>
            <para>For a one dimentional array this is the
            array type name, an open brace, followed by a comma
            seperated list of the elements (using the appropriate
            renderer), followed by a close brace. For example:
            <c>int[] {1, 2, 3}</c>.</para>
            <para>If the array is not one dimentional the
            <c>Array.ToString()</c> is returned.</para>
            </remarks>
        </member>
        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderException(log4net.ObjectRenderer.RendererMap,System.Exception)">
            <summary>
            Render the exception into a string
            </summary>
            <param name="rendererMap">The map used to lookup renderers</param>
            <param name="ex">the exception to render</param>
            <returns>the string representation of the exception</returns>
            <remarks>
            <para>Renders the exception type, message, and stack trace. Any nested
            exceptions are also rendered.</para>

            <para>The <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderExceptionMessage(log4net.ObjectRenderer.RendererMap,System.Exception)"/>
            method is called to render the Exception's message into a string. This method
            can be overriden to change the behaviour when rendereing
            exceptions. To change or extend only the message that is
            displayed override the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderExceptionMessage(log4net.ObjectRenderer.RendererMap,System.Exception)"/>
            method instead.</para>
            </remarks>
        </member>
        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderExceptionMessage(log4net.ObjectRenderer.RendererMap,System.Exception)">
            <summary>
            Render the exception message into a string
            </summary>
            <param name="rendererMap">The map used to lookup renderers</param>
            <param name="ex">the exception to get the message from and render</param>
            <returns>the string representation of the exception message</returns>
            <remarks>
            <para>This method is called to render the exception's message into
            a string. This method should be overriden to extend the information
            that is rendered for a specific exception.</para>

            <para>See <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderException(log4net.ObjectRenderer.RendererMap,System.Exception)"/> for more information.</para>
            </remarks>
        </member>
        <member name="T:log4net.ObjectRenderer.RendererMap">
            <summary>
            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
            </summary>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
            <summary>
            Render <paramref name="obj"/> using the appropriate renderer.
            </summary>
            <remarks>
            <para>Find the appropriate renderer for the type of the
            <paramref name="obj"/> parameter. This is accomplished by calling the
            <see cref="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)"/> method. Once a renderer is found, it is
            applied on the object <paramref name="obj"/> and the result is returned
            as a <see cref="T:System.String"/>.</para>
            </remarks>
            <param name="obj">the object to render to a string</param>
            <returns>the string rendering of <paramref name="obj"/></returns>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
            <summary>
            Gets the renderer for the specified object type
            </summary>
            <remarks>
            <param>Gets the renderer for the specified object type</param>

            <param>Syntactic sugar method that calls <see cref="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)"/>
            with the type of the object parameter.</param>
            </remarks>
            <param name="obj">the object to lookup the renderer for</param>
            <returns>the renderer for <paramref name="obj"/></returns>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
            <summary>
            Gets the renderer for the specified type
            </summary>
            <param name="type">the type to lookup the renderer for</param>
            <returns>the renderer for the specified type</returns>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.SearchInterfaces(System.Type)">
            <summary>
            Internal function to recusivly search interfaces
            </summary>
            <param name="type">the type to lookup the renderer for</param>
            <returns>the renderer for the specified type</returns>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
            <summary>
            Clear the map of renderers
            </summary>
        </member>
        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
            <summary>
            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="type"/>.
            </summary>
            <param name="type">the type that will be rendered by <paramref name="or"/></param>
            <param name="or">the renderer for <paramref name="type"/></param>
        </member>
        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
            <summary>
            Get the default renderer instance
            </summary>
            <returns>the default renderer</returns>
        </member>
        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">
            <summary>
            Implementation of DefaultLoggerFactory.
            </summary>
        </member>
        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">
            <summary>
            Implement this interface to create new instances of Logger or a sub-class of Logger.
            </summary>
            <remarks>
            <para>This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to
            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.</para>

            <para>The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.MakeNewLoggerInstance(System.String)"/> method is called
            to create a named logger.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.MakeNewLoggerInstance(System.String)">
            <summary>
            Construct a new Logger instance with the name specified
            </summary>
            <param name="name">the name of the logger</param>
            <returns>the instance for the name specified</returns>
            <remarks>
            <para>Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create
            new names <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.MakeNewLoggerInstance(System.String)">
            <summary>
            Construct a new Logger object
            </summary>
            <param name="name">The name of the Logger</param>
            <returns>a new Logger instance</returns>
        </member>
        <member name="T:log4net.Repository.Hierarchy.Logger">
            <summary>
            Internal class used to provide implmentation of <see cref="T:log4net.ILog"/>
            interface. Applications should use <see cref="T:log4net.LogManager"/> to get
            logger instances.
            </summary>
            <remarks>
            This is one of the central class' in the log4net implementation. One of the
            distintive features of log4net are hierarchical loggers and their
            evaluation.
            </remarks>
        </member>
        <member name="T:log4net.ILog">
            <summary>
            The ILog interface is use by application to log messages into
            the log4net framework.
            </summary>
            <remarks>
            <para>Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
            that implement this interface. The <see cref="M:log4net.LogManager.GetLogger(System.String)"/>
            static method is used to get logger instances.</para>

            <para>Contains methods for logging at different levels. Also
            has properties for determining if those logging priorities are
            enabled in the current configuration.</para>
            </remarks>
            <example>Simple example of logging messages
            <code>
            ILog log = LogManager.GetLogger("application-log");

            log.Info("Application Start");
            log.Debug("This is a debug message");

            if (log.IsDebugEnabled)
            {
                log.Debug("This is another debug message");
            }
            </code>
            </example>
            <seealso cref="T:log4net.LogManager"/>
            <seealso cref="M:log4net.LogManager.GetLogger(System.String)"/>
        </member>
        <member name="M:log4net.ILog.Debug(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.DEBUG"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>DEBUG</c>
            enabled by comparing the level of this logger with the
            <see cref="F:log4net.spi.Level.DEBUG"/> level. If this logger is
            <c>DEBUG</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
            <seealso cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>DEBUG</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <remarks>
            See the <see cref="M:log4net.ILog.Debug(System.Object)"/> form for more detailed information.
            </remarks>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="M:log4net.ILog.Info(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.INFO"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>INFO</c>
            enabled by comparing the level of this logger with the
            <see cref="F:log4net.spi.Level.INFO"/> level. If this logger is
            <c>INFO</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
            <seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        </member>
        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>INFO</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <remarks>
            See the <see cref="M:log4net.ILog.Info(System.Object)"/> form for more detailed information.
            </remarks>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
        </member>
        <member name="M:log4net.ILog.Warn(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.WARN"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>WARN</c>
            enabled by comparing the level of this logger with the
            <see cref="F:log4net.spi.Level.WARN"/> level. If this logger is
            <c>WARN</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
            <seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        </member>
        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>WARN</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <remarks>
            See the <see cref="M:log4net.ILog.Warn(System.Object)"/> form for more detailed information.
            </remarks>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
        </member>
        <member name="M:log4net.ILog.Error(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.ERROR"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>ERROR</c>
            enabled by comparing the level of this logger with the
            <see cref="F:log4net.spi.Level.ERROR"/> level. If this logger is
            <c>ERROR</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
            <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        </member>
        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>ERROR</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <remarks>
            See the <see cref="M:log4net.ILog.Error(System.Object)"/> form for more detailed information.
            </remarks>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
        </member>
        <member name="M:log4net.ILog.Fatal(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.FATAL"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>FATAL</c>
            enabled by comparing the level of this logger with the
            <see cref="F:log4net.spi.Level.FATAL"/> level. If this logger is
            <c>FATAL</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
            <seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        </member>
        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>FATAL</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <remarks>
            See the <see cref="M:log4net.ILog.Fatal(System.Object)"/> form for more detailed information.
            </remarks>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
        </member>
        <member name="P:log4net.ILog.IsDebugEnabled">
            <summary>
            Check if this logger is enabled for the DEBUG <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>DEBUG</c> events.
            </value>
            <remarks>
            <para>This function is intended to lessen the computational cost of
            disabled log debug statements.</para>

            <para> For some ILog interface <c>log</c>, when you write:</para>
            <code>
            log.Debug("This is entry number: " + i );
            </code>

            <para>You incur the cost constructing the message, string construction and concatenation in
            this case, regardless of whether the message is logged or not.</para>

            <para>If you are worried about speed (who isn't), then you should write:</para>
            <code>
            if (log.IsDebugEnabled)
            {
                log.Debug("This is entry number: " + i );
            }
            </code>

            <para>This way you will not incur the cost of parameter
            construction if debugging is disabled for <c>log</c>. On
            the other hand, if the <c>log</c> is debug enabled, you
            will incur the cost of evaluating whether the logger is debug
            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
            the <see cref="M:log4net.ILog.Debug(System.Object)"/>.  This is an insignificant overhead
            since evaluating a logger takes about 1% of the time it
            takes to actually log. This is the prefered style of logging.</para>

            <para>Alternativly if your logger is available staticaly then the is debug
            enabled state can be stored in a static variable like this:</para>
            <code>
            private static readonly bool isDebugEnabled = log.IsDebugEnabled;
            </code>

            <para>Then when you come to log you can write:</para>
            <code>
            if (isDebugEnabled)
            {
                log.Debug("This is entry number: " + i );
            }
            </code>

            <para>This way the debug enabled state is only queried once
            when the class is loaded. Using a <c>private static readonly</c>
            variable is the most efficient because it is a run time constant
            and can be heavily optimised by the JIT compiler.</para>

            <para>Of course if you use a static readonly variable to
            hold the enabled state of the logger then you cannot
            change the enabled state at runtime to vary the logging
            that is produced. You have to decide if you need absolute
            speed or runtime flexibility.</para>
            </remarks>
            <returns><c>true</c> if this logger is debug enabled, <c>false</c> otherwise</returns>
            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
        </member>
        <member name="P:log4net.ILog.IsInfoEnabled">
            <summary>
            Check if this logger is enabled for the INFO <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>INFO</c> events.
            </value>
            <remarks>
            For more infomation see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>INFO</c> level.</returns>
            <seealso cref="M:log4net.ILog.Info(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.ILog.IsWarnEnabled">
            <summary>
            Check if this logger is enabled for the WARN <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>WARN</c> events.
            </value>
            <remarks>
            For more infomation see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>WARN</c> level.</returns>
            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.ILog.IsErrorEnabled">
            <summary>
            Check if this logger is enabled for the ERROR <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>ERROR</c> events.
            </value>
            <remarks>
            For more infomation see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>ERROR</c> level.</returns>
            <seealso cref="M:log4net.ILog.Error(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.ILog.IsFatalEnabled">
            <summary>
            Check if this logger is enabled for the FATAL <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>FATAL</c> events.
            </value>
            <remarks>
            For more infomation see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>FATAL</c> level.</returns>
            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.FQCN">
            <summary>
            The fully qualified name of the Logger class.
            </summary>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">
            <summary>
            The name of this logger.
            </summary>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">
            <summary>
            The assigned level of this logger.
            </summary>
            <remarks>
            The <c>level</c> variable need not be
            assined a value in which case it is inherited
            form the hierarchy.
            </remarks>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">
            <summary>
            The parent of this logger.
            </summary>
            <remarks>
            The parent of this logger. All loggers have at least one ancestor which is the root logger.
            </remarks>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">
            <summary>
            Loggers need to know what Hierarchy they are in.
            </summary>
            <remarks>
            Loggers need to know what Hierarchy they are in.
            The hierarchy that this logger is a member of is stored
            here.
            </remarks>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.m_aai">
            <summary>
            Helper implementation of the <see cref="T:log4net.spi.IAppenderAttachable"/> interface
            </summary>
        </member>
        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">
            <summary>
            Flag indicating if child loggers inherit their parents appenders
            </summary>
            <remarks>
            Additivity is set to true by default, that is children inherit
            the appenders of their ancestors by default. If this variable is
            set to <c>false</c> then the appenders found in the
            ancestors of this logger are not used. However, the children
            of this logger will inherit its appenders, unless the children
            have their additivity flag set to <c>false</c> too. See
            the user manual for more details.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">
            <summary>
            This constructor created a new <c>Logger</c> instance and
            sets its name.
            </summary>
            <remarks>
            This constructor created a new <c>Logger</c> instance and
            sets its name.

            <para>It is intended to be used by sub-classes only. You can't
            create loggers directly.</para>

            <para>Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>
            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default
            logger creator</para>
            </remarks>
            <param name="name">The name of the logger</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">
            <summary>
            Add <paramref name="newAppender"/> to the list of appenders of this
            Logger instance.
            </summary>
            <param name="newAppender">An appender to add to this logger</param>
            <remarks>
            Add <paramref name="newAppender"/> to the list of appenders of this
            Logger instance.
            <para>If <paramref name="newAppender"/> is already in the list of
            appenders, then it won't be added again.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.GetAllAppenders">
            <summary>
            Get the appenders contained in this logger as an
            <see cref="T:System.Collections.ICollection"/>.
            </summary>
            <remarks>
            Get the appenders contained in this logger as an
            <see cref="T:System.Collections.ICollection"/>. If no appenders
            can be found, then a <see cref="T:log4net.helpers.EmptyCollection"/> is returned.
            </remarks>
            <returns>A collection of the appenders in this logger</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">
            <summary>
            Look for the appender named as <c>name</c>
            </summary>
            <param name="name">The name of the appender to lookup</param>
            <returns>The appender with the name specified, or <c>null</c>.</returns>
            <remarks>
            Returns the named appender, or null if the appender is not found.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">
            <summary>
            Remove all previously added appenders from this Logger instance.
            </summary>
            <remarks>
            Remove all previously added appenders from this Logger instance.
            <para>This is useful when re-reading configuration information.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">
            <summary>
            Remove the appender passed as parameter form the list of appenders.
            </summary>
            <param name="appender">The appender to remove</param>
            <remarks>
            Remove the appender passed as parameter form the list of appenders.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">
            <summary>
            Remove the appender passed as parameter form the list of appenders.
            </summary>
            <param name="name">The name of the appender to remove</param>
            <remarks>
            Remove the named appender passed as parameter form the list of appenders.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Debug(System.Object)">
            <summary>
            Log a message object with the <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>DEBUG</c>
            enabled by comparing the level of this logger with the
            <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level. If this logger is
            <c>DEBUG</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Repository.Hierarchy.Logger.Debug(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Debug(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>DEBUG</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Repository.Hierarchy.Logger.Debug(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Repository.Hierarchy.Logger.Debug(System.Object)"/>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Info(System.Object)">
            <summary>
            Log a message object with the <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>INFO</c>
            enabled by comparing the level of this logger with the
            <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level. If this logger is
            <c>INFO</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Repository.Hierarchy.Logger.Info(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Info(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>INFO</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Repository.Hierarchy.Logger.Info(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Repository.Hierarchy.Logger.Info(System.Object)"/>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Warn(System.Object)">
            <summary>
            Log a message object with the <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>WARN</c>
            enabled by comparing the level of this logger with the
            <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level. If this logger is
            <c>WARN</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Repository.Hierarchy.Logger.Warn(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Warn(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>WARN</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Repository.Hierarchy.Logger.Warn(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Repository.Hierarchy.Logger.Warn(System.Object)"/>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Error(System.Object)">
            <summary>
            Log a message object with the <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>ERROR</c>
            enabled by comparing the level of this logger with the
            <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level. If this logger is
            <c>ERROR</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Repository.Hierarchy.Logger.Error(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Error(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>ERROR</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Repository.Hierarchy.Logger.Error(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Repository.Hierarchy.Logger.Error(System.Object)"/>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Fatal(System.Object)">
            <summary>
            Log a message object with the <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this logger is <c>FATAL</c>
            enabled by comparing the level of this logger with the
            <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> level. If this logger is
            <c>FATAL</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this logger and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Repository.Hierarchy.Logger.Fatal(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Fatal(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>FATAL</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Repository.Hierarchy.Logger.Fatal(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Repository.Hierarchy.Logger.Fatal(System.Object)"/>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.spi.LoggingEvent)">
            <summary>
            Call the appenders in the hierrachy starting at
            <c>this</c>.  If no appenders could be found, emit a
            warning.
            </summary>
            <remarks>
            This method calls all the appenders inherited from the
            hierarchy circumventing any evaluation of whether to log or not
            to log the particular log request.
            </remarks>
            <param name="loggingEvent">the event to log</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">
            <summary>
            Close all attached appenders implementing the IAppenderAttachable interface.
            </summary>
            <remarks>
            Used to ensure that the appenders are correctly shutdown.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.spi.Level,System.Object,System.Exception)">
            <summary>
            This generic form is intended to be used by wrappers
            </summary>
            <param name="level">The level of the message to be logged</param>
            <param name="message">The message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            Generate a logging event for the specified <paramref name="level"/> using
            the <paramref name="message"/> and <paramref name="t"/>.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.spi.Level,System.Object)">
            <summary>
            This generic form is intended to be used by wrappers
            </summary>
            <param name="level">The level of the message to be logged</param>
            <param name="message">The message object to log</param>
            <remarks>
            Generate a logging event for the specified <paramref name="level"/> using
            the <paramref name="message"/>.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.String,log4net.spi.Level,System.Object,System.Exception)">
            <summary>
            This is the most generic printing method. This generic form is intended to be used by wrappers
            </summary>
            <param name="callerFQCN">The wrapper class' fully qualified class name</param>
            <param name="level">The level of the message to be logged</param>
            <param name="message">The message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            Generate a logging event for the specified <paramref name="level"/> using
            the <paramref name="message"/>.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.spi.LoggingEvent)">
            <summary>
            This is the most generic printing method. This generic form is intended to be used by wrappers
            </summary>
            <param name="logEvent">the event being logged</param>
            <remarks>
            Generate a logging event for the specified <paramref name="level"/> using
            the <paramref name="message"/>.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.String,log4net.spi.Level,System.Object,System.Exception)">
            <summary>
            This method creates a new logging event and logs the event without further checks.
            </summary>
            <param name="fqcn">The wrapper class' fully qualified class name</param>
            <param name="level">The level of the message to be logged</param>
            <param name="message">The message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            This method generates a logging event and delivers it to the attached
            appenders.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.spi.LoggingEvent)">
            <summary>
            This method creates a new logging event and logs the event without further checks.
            </summary>
            <param name="logEvent">the event being logged</param>
            <remarks>
            This method generates a logging event and delivers it to the attached
            appenders.
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.GetEffectiveLevel">
            <summary>
            Get the applied level for this logger.
            </summary>
            <remarks>
            Starting from this logger, search the logger hierarchy for a
            non-null level and return it. Otherwise, return the level of the
            root logger.
            <para>The Logger class is designed so that this method executes as
            quickly as possible.</para>
            </remarks>
            <returns>the nearest level in the logger hierarchy</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.GetChainedLevel">
            <summary>
            Get the applied level for this logger.
            </summary>
            <remarks>
            Starting from this logger, search the logger hierarchy for a
            non-null level and return it. Otherwise, return the level of the
            root logger.
            <para>The Logger class is designed so that this method executes as
            quickly as possible.</para>
            </remarks>
            <returns>the nearest level in the logger hierarchy</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.spi.Level)">
            <summary>
            Check if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
            </summary>
            <param name="level">The level to check</param>
            <returns>boolean True if this logger is enabled for <c>level</c>.</returns>
            <remarks>
            Check if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.
            </remarks>
            <seealso cref="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled">
            <summary>
            Check if this logger is enabled for the <c>DEBUG</c>
            level.
            </summary>
            <value>
            True if this logger is enabled for <c>DEBUG</c> events.
            </value>
            <remarks>
            <para>This function is intended to lessen the computational cost of
            disabled log debug statements.</para>

            <para> For some <c>log</c> Logger object, when you write:</para>
            <code>
            log.Debug("This is entry number: " + i );
            </code>

            <para>You incur the cost constructing the message, concatenation in
            this case, regardless of whether the message is logged or not.</para>

            <para>If you are worried about speed, then you should write:</para>
            <code>
            if (log.IsDebugEnabled())
            {
                log.Debug("This is entry number: " + i );
            }
            </code>

            <para>This way you will not incur the cost of parameter
            construction if debugging is disabled for <c>log</c>. On
            the other hand, if the <c>log</c> is debug enabled, you
            will incur the cost of evaluating whether the logger is debug
            enabled twice. Once in <c>IsDebugEnabled</c> and once in
            the <c>Debug</c>.  This is an insignificant overhead
            since evaluating a logger takes about 1% of the time it
            takes to actually log.</para>
            </remarks>
            <returns><c>true</c> if this logger is debug enabled, <c>false</c> otherwise</returns>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.IsInfoEnabled">
            <summary>
            Check if this logger is enabled for the INFO <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>INFO</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>INFO</c> level.</returns>
            <seealso cref="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.IsWarnEnabled">
            <summary>
            Check if this logger is enabled for the WARN <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>WARN</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>WARN</c> level.</returns>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.IsErrorEnabled">
            <summary>
            Check if this logger is enabled for the ERROR <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>ERROR</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>ERROR</c> level.</returns>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.IsFatalEnabled">
            <summary>
            Check if this logger is enabled for the FATAL <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.
            </summary>
            <value>
            True if this logger is enabled for <c>FATAL</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Repository.Hierarchy.Logger.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this logger is enabled for the <c>FATAL</c> level.</returns>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">
            <summary>
            The parent logger in the hierarchy
            </summary>
            <value>
            The parent logger in the hierarchy
            </value>
            <remarks>
            Part of the Composite pattern that makes the hierarchy.
            </remarks>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">
            <summary>
            Flag indicating if child loggers inherit their parent's appenders
            </summary>
            <value>
            true if child loggers inherit their parent's appenders
            </value>
            <remarks>
            Additivity is set to true by default, that is children inherit
            the appenders of their ancestors by default. If this variable is
            set to <c>false</c> then the appenders found in the
            ancestors of this logger are not used. However, the children
            of this logger will inherit its appenders, unless the children
            have their additivity flag set to <c>false</c> too. See
            the user manual for more details.
            </remarks>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">
            <summary>
            Get / Set the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this
            <c>Logger</c> instance is attached.
            </summary>
            <value>The hierarchy that this logger belongs to</value>
            <remarks>
            Get / Set the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this
            <c>Logger</c> instance is attached.
            </remarks>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.Name">
            <summary>
            Return the logger name.
            </summary>
            <value>
            The name of the logger
            </value>
            <remarks>
            The name of the logger
            </remarks>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Logger.Level">
            <summary>
            Returns the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.
            The assigned Level, can be <c>null</c>
            </summary>
            <value>
            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.
            </value>
            <remarks>
            Loggers have assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> levels.
            </remarks>
        </member>
        <member name="T:log4net.Repository.Hierarchy.DOMHierarchyConfigurator">
            <summary>
            Use this class to initialize the log4net environment using a DOM tree.
            </summary>
            <remarks>
            Configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM tree.
            </remarks>
        </member>
        <member name="F:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.m_appenderBag">
            <summary>
            key: appenderName, value: appender
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.#ctor">
            <summary>
            No argument constructor.
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.Configure(log4net.Repository.Hierarchy.Hierarchy,System.Xml.XmlElement)">
            <summary>
            Used internally to configure the log4net framework by parsing a DOM tree of XML elements.
            </summary>
            <param name="hierarchy">the hierarchy to build</param>
            <param name="element">the root element to parse</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">
            <summary>
            Used internally to parse appenders by IDREF.
            </summary>
            <param name="appenderRef">the appender ref element</param>
            <returns>the instance of the appender that the ref referes to</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">
            <summary>
            Used internally to parse an appender element.
            </summary>
            <param name="appenderElement">the appender element</param>
            <returns>the appender instance</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseErrorHandler(System.Xml.XmlElement,log4net.Appender.IAppender)">
            <summary>
            Used internally to parse an error handler element.
            </summary>
            <param name="element">the error hander element</param>
            <param name="appender">the appender to set the error handler on</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseFilters(System.Xml.XmlElement,log4net.Appender.IAppender)">
            <summary>
            Used internally to parse a filter element.
            </summary>
            <param name="element">the filter element</param>
            <param name="appender">the appender to add the filter to</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseLogger(System.Xml.XmlElement,log4net.Repository.Hierarchy.Hierarchy)">
            <summary>
            Used internally to parse an logger element.
            </summary>
            <param name="loggerElement">the logger element</param>
            <param name="hierarchy">the hierarchy to add the logger to</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseLoggerFactory(System.Xml.XmlElement,log4net.Repository.Hierarchy.Hierarchy)">
            <summary>
            Used internally to parse the logger factory element.
            </summary>
            <param name="factoryElement">the factory element</param>
            <param name="hierarchy">the hierarchy to set the logger factory on</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseRoot(System.Xml.XmlElement,log4net.Repository.Hierarchy.Hierarchy)">
            <summary>
            Used internally to parse the roor logger element.
            </summary>
            <param name="rootElement">the root element</param>
            <param name="hierarchy">the hierarchy to set the root element on</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
            <summary>
            Used internally to parse the children of a logger element.
            </summary>
            <param name="catElement">the catefory element</param>
            <param name="log">the logger instance</param>
            <param name="isRoot">flag to indicate if the logger is the root logger</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseLayout(System.Xml.XmlElement)">
            <summary>
            Used internally to parse a layout element.
            </summary>
            <param name="element">the layout element</param>
            <returns>the instance of the layout object</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement,log4net.Repository.Hierarchy.Hierarchy)">
            <summary>
            Used internally to parse an object renderer
            </summary>
            <param name="element">the renderer element</param>
            <param name="hierarchy">the hierarchy to add the renderer to</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">
            <summary>
            Used internally to parse a level element.
            </summary>
            <param name="element">the level element</param>
            <param name="log">the logger object to set the level on</param>
            <param name="isRoot">flag to indicate if the logger is the root logger</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">
            <summary>
            Internal function to set a param on an object.
            </summary>
            <remarks>
            The param name must correspond to a writable property
            on the object. The value of the param 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="elem">the param element</param>
            <param name="target">the object to set the param on</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.DOMHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement)">
            <summary>
            Create an object as specified in XML
            </summary>
            <param name="elem">the XML element that contains the definition of the object</param>
            <returns>the object or null</returns>
        </member>
        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
            <summary>
            Delegate used to handle logger creation event notifications
            </summary>
            <param name="sender">The <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> in which the <see cref="T:log4net.Repository.Hierarchy.Logger"/>
            has been created.</param>
            <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args
            that holds the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
            <remarks>
            Delegate used to handle logger creation event notifications
            </remarks>
        </member>
        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
            <summary>
            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreated"/> event.
            </summary>
            <remarks>
            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreated"/> event is raised every time a
            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
            </remarks>
        </member>
        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
            <summary>
            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
            <summary>
            Construct instance using <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> specified
            </summary>
            <param name="log">the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created</param>
        </member>
        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
            <summary>
            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created
            </summary>
            <value>
            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created
            </value>
        </member>
        <member name="T:log4net.Repository.Hierarchy.Hierarchy">
            <summary>
            This class is specialized in retrieving loggers by name and
            also maintaining the logger hierarchy. Implements the
            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
            </summary>
            <remarks>
            <para><i>The casual user should not have to deal with this class
            directly.</i></para>

            <para>The structure of the logger hierarchy is maintained by the
            <see cref="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)"/> method. The hierarchy is such that children
            link to their parent but parents do not have any references to their
            children. Moreover, loggers can be instantiated in any order, in
            particular descendant before ancestor.</para>

            <para>In case a descendant is created before a particular ancestor,
            then it creates a provision node for the ancestor and adds itself
            to the provision node. Other descendants of the same ancestor add
            themselves to the previously created provision node.</para>
            </remarks>
        </member>
        <member name="T:log4net.Repository.LoggerRepositorySkeleton">
            <summary>
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="T:log4net.Repository.ILoggerRepository">
            <summary>
            Interface implemented by logger repositories.
            </summary>
            <remarks>
            <para>This interface is implemented by logger repositories. e.g.
            <see cref="N:log4net.Repository.Hierarchy"/>.</para>

            <para>This interface is used by the <see cref="T:log4net.LogManager"/>
            to obtain <see cref="T:log4net.ILog"/> interfaces.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
            <summary>
            Check if the named logger exists in the repository. If so return
            its reference, otherwise returns <c>null</c>.
            </summary>
            <param name="name">The name of the logger to lookup</param>
            <returns>The Logger object with the name specified</returns>
            <remarks>
            <para>If the names logger exists it is returned, otherwise
            <c>null</c> is returned.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
            <summary>
            Returns all the currently defined loggers as an Array.
            </summary>
            <returns>All the defined loggers</returns>
            <remarks>
            <para>Returns all the currently defined loggers as an Array.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
            <summary>
            Returns a named logger instance
            </summary>
            <param name="name">The name of the logger to retrieve</param>
            <returns>The logger object with the name specified</returns>
            <remarks>
            <para>Returns a named logger instance</para>

            <para>If a logger of that name already exists, then it will be
            returned.  Otherwise, a new logger will be instantiated and
            then linked with its existing ancestors as well as children.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
            <summary>Shutdown the repository</summary>
            <remarks>
            <para>Shutting down a repository will <i>safely</i> close and remove
            all appenders in all loggers including the root logger.</para>

            <para>Some appenders need to be closed before the
            application exists. Otherwise, pending logging events might be
            lost.</para>

            <para>The <see cref="M:log4net.Repository.ILoggerRepository.Shutdown"/> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a logger
            and again to a nested appender.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
            <summary>
            Reset the repositories configuration to a default state
            </summary>
            <remarks>
            <para>Reset all values contained in this instance to their
            default state.</para>

            <para>Existing loggers are not removed. They are just reset.</para>

            <para>This method should be used sparingly and with care as it will
            block all logging until it is completed.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.spi.LoggingEvent)">
            <summary>
            Log the <see cref="T:log4net.spi.LoggingEvent"/> through this repository.
            </summary>
            <param name="logEvent">the event to log</param>
            <remarks>
            <para>
            This method should not normally be used to log.
            The <see cref="T:log4net.ILog"/> interface should be used
            for routine logging. This inferface can be obtained
            using the <see cref="M:log4net.LogManager.GetLogger(System.String)"/> method.
            </para>
            <para>
            The <c>logEvent</c> is delivered to the appropriate logger and
            that logger is then responsible for logging the event.
            </para>
            </remarks>
        </member>
        <member name="P:log4net.Repository.ILoggerRepository.Name">
            <summary>
            The name of the repository
            </summary>
            <value>
            The name of the repository
            </value>
            <remarks>
            <para>The name of the repository</para>
            </remarks>
        </member>
        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
            <summary>
            RendererMap accesses the object renderer map for this repository.
            </summary>
            <value>
            RendererMap accesses the object renderer map for this repository.
            </value>
            <remarks>
            <para>RendererMap accesses the object renderer map for this repository.</para>

            <para>The RendererMap holds a mapping between types and
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.</para>
            </remarks>
        </member>
        <member name="P:log4net.Repository.ILoggerRepository.Threshold">
            <summary>
            The threshold for all events in this repository
            </summary>
            <value>
            The threshold for all events in this repository
            </value>
            <remarks>
            The threshold for all events in this repository
            </remarks>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
            <summary>
            Create a new Logger hierarchy.
            </summary>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
            <summary>
            Check if the named logger exists in the hierarchy. If so return
            its reference, otherwise returns <c>null</c>.
            </summary>
            <param name="name">The name of the logger to lookup</param>
            <returns>The Logger object with the name specified</returns>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
            <summary>
            Returns all the currently defined loggers in the hierarchy as an Array
            </summary>
            <remarks>
            Returns all the currently defined loggers in the hierarchy as an Array.
            The root logger is <b>not</b> included in the returned
            enumeration.
            </remarks>
            <returns>All the defined loggers</returns>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
            <summary>
            Return a new logger instance
            </summary>
            <remarks>
            <para>Return a new logger instance.</para>

            <para>If a logger of that name already exists, then it will be
            returned.  Otherwise, a new logger will be instantiated and
            then linked with its existing ancestors as well as children.</para>
            </remarks>
            <param name="name">The name of the logger to retrieve</param>
            <returns>The logger object with the name specified</returns>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
            <summary>
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
            <summary>
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.spi.LoggingEvent)">
            <summary>
            Log the logEvent through this hierarchy.
            </summary>
            <param name="logEvent">the event to log</param>
            <remarks>
            <para>
            This method should not normally be used to log.
            The <see cref="T:log4net.ILog"/> interface should be used
            for routine logging. This inferface can be obtained
            using the <see cref="M:log4net.LogManager.GetLogger(System.String)"/> method.
            </para>
            <para>
            The <c>logEvent</c> is delivered to the appropriate logger and
            that logger is then responsible for logging the event.
            </para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
            <summary>
            Add an object renderer for a specific class.
            </summary>
            <param name="classToRender">The type that will be rendered by the renderer supplied</param>
            <param name="or">The object renderer used to render the object</param>
        </member>
        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
            <summary>
            The name of the repository
            </summary>
            <value>
            The string name of the repository
            </value>
        </member>
        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
            <summary>
            The threshold for all events in this repository
            </summary>
            <value>
            The threshold for all events in this repository
            </value>
            <remarks>
            The threshold for all events in this repository
            </remarks>
        </member>
        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
            <summary>
            the object renderer map for this hierarchy.
            </summary>
            <value>
            the object renderer map for this hierarchy.
            </value>
        </member>
        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
            <summary>
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
            <summary>
            Initialise the log4net system using the specified appender
            </summary>
            <param name="appender">the appender to use to log all logging events</param>
        </member>
        <member name="T:log4net.Repository.IDOMRepositoryConfigurator">
            <summary>
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:log4net.Repository.IDOMRepositoryConfigurator.Configure(System.Xml.XmlElement)">
            <summary>
            Initialise the log4net system using the specified config
            </summary>
            <param name="element">the element containing the root of the config</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
            <summary>
            Create a new Logger hierarchy.
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
            <summary>
            Create a new Logger hierarchy.
            </summary>
            <param name="loggerFactory">The factory to use to create new logger instances</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
            <summary>
            Check if the named logger exists in the hierarchy. If so return
            its reference, otherwise returns <c>null</c>.
            </summary>
            <param name="name">The name of the logger to lookup</param>
            <returns>The Logger object with the name specified</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
            <summary>
            Returns all the currently defined loggers in the hierarchy as an Array
            </summary>
            <remarks>
            Returns all the currently defined loggers in the hierarchy as an Array.
            The root logger is <b>not</b> included in the returned
            enumeration.
            </remarks>
            <returns>All the defined loggers</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
            <summary>
            Return a new logger instance named as the first parameter using
            the default factory.
            </summary>
            <remarks>
            Return a new logger instance named as the first parameter using
            the default factory.

            <para>If a logger of that name already exists, then it will be
            returned.  Otherwise, a new logger will be instantiated and
            then linked with its existing ancestors as well as children.</para>
            </remarks>
            <param name="name">The name of the logger to retrieve</param>
            <returns>The logger object with the name specified</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
            <summary>
            Shutting down a hierarchy will <i>safely</i> close and remove
            all appenders in all loggers including the root logger.
            </summary>
            <remarks>
            Shutting down a hierarchy will <i>safely</i> close and remove
            all appenders in all loggers including the root logger.

            <para>Some appenders need to be closed before the
            application exists. Otherwise, pending logging events might be
            lost.</para>

            <para>The <c>Shutdown</c> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a logger
            and again to a nested appender.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
            <summary>
            Reset all values contained in this hierarchy instance to their default.
            </summary>
            <remarks>
            Reset all values contained in this hierarchy instance to their
            default.  This removes all appenders from all loggers, sets
            the level of all non-root loggers to <c>null</c>,
            sets their additivity flag to <c>true</c> and sets the level
            of the root logger to <see cref="F:log4net.spi.Level.DEBUG"/>. Moreover,
            message disabling is set its default "off" value.

            <para>Existing loggers are not removed. They are just reset.</para>

            <para>This method should be used sparingly and with care as it will
            block all logging until it is completed.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.spi.LoggingEvent)">
            <summary>
            Log the logEvent through this hierarchy.
            </summary>
            <param name="logEvent">the event to log</param>
            <remarks>
            <para>
            This method should not normally be used to log.
            The <see cref="T:log4net.ILog"/> interface should be used
            for routine logging. This inferface can be obtained
            using the <see cref="M:log4net.LogManager.GetLogger(System.String)"/> method.
            </para>
            <para>
            The <c>logEvent</c> is delivered to the appropriate logger and
            that logger is then responsible for logging the event.
            </para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.spi.Level)">
            <summary>
            This method will return <c>true</c> if this repository is
            disabled for <c>level</c> object passed as parameter and
            <c>false</c> otherwise. See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
            </summary>
            <param name="level">the level to check agains</param>
            <returns>true if the repository is disabled for the level argument</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
            <summary>
            Clear all logger definitions from the internal hashtable
            </summary>
            <remarks>
            This call will clear all logger definitions from the internal
            hashtable. Invoking this method will irrevocably mess up the
            logger hierarchy.

            <para>You should <b>really</b> know what you are doing before
            invoking this method.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Disable(System.String)">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
            <param name="levelStr">The level to disable, as a string</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Disable(log4net.spi.Level)">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
            <param name="p">Disable all logging requests of level <i>equal to or below</i> the level parameter</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.DisableAll">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.DisableDebug">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.DisableInfo">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.EnableAll">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.FireLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
            <summary>
            Sends a logger creation event to all registered listeners
            </summary>
            <param name="logger">The newly created logger</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
            <summary>
            Return a new logger instance named as the first parameter using
            <paramref name="factory"/>.
            </summary>
            <remarks>
            If a logger of that name already exists, then it will be
            returned. Otherwise, a new logger will be instantiated by the
            <paramref name="factory"/> parameter and linked with its existing
            ancestors as well as children.
            </remarks>
            <param name="name">The name of the logger to retrieve</param>
            <param name="factory">The factory that will make the new logger instance</param>
            <returns>The logger object with the name specified</returns>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OverrideAsNeeded(System.String)">
            <summary>
            Obsolete. Method removed without replacement.
            </summary>
            <param name="overrideStr">String that is either <c>true</c> or <c>false</c></param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.SetDisableOverride(System.String)">
            <summary>
            Obsolete. Method removed without replacement.
            </summary>
            <param name="overrideStr">String that is either 'true' or 'false'</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
            <summary>
            Updates all the parents of the specified logger
            </summary>
            <remarks>
            This method loops through all the <i>potential</i> parents of
            'log'. There 3 possible cases:
            <list type="number">
                <item>
                    <term>No entry for the potential parent of 'log' exists</term>
                    <description>We create a ProvisionNode for this potential
                    parent and insert 'log' in that provision node.</description>
                </item>
                <item>
                    <term>There entry is of type Logger for the potential parent.</term>
                    <description>The entry is 'log's nearest existing parent. We
                    update log's parent field with this entry. We also break from
                    he loop because updating our parent's parent is our parent's
                    responsibility.</description>
                </item>
                <item>
                    <term>There entry is of type ProvisionNode for this potential parent.</term>
                    <description>We add 'log' to the list of children for this
                    potential parent.</description>
                </item>
            </list>
            </remarks>
            <param name="log">The logger to update the parents for</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
            <summary>
            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
            </summary>
            <remarks>
            <para>We update the links for all the children that placed themselves
            in the provision node 'pn'. The second argument 'log' is a
            reference for the newly created Logger, parent of all the
            children in 'pn'</para>

            <para>We loop on all the children 'c' in 'pn':</para>

            <para>If the child 'c' has been already linked to a child of
            'log' then there is no need to update 'c'.</para>

            <para>Otherwise, we set log's parent field to c's parent and set
            c's parent field to log.</para>
            </remarks>
            <param name="pn"></param>
            <param name="log"></param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
            <summary>
            Initialise the log4net system using the specified appender
            </summary>
            <param name="appender">the appender to use to log all logging events</param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IDOMRepositoryConfigurator#Configure(System.Xml.XmlElement)">
            <summary>
            Initialise the log4net system using the specified config
            </summary>
            <param name="element">the element containing the root of the config</param>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
            <summary>
            Flag to indicate if we have already issued a warning
            about not having an appender warning.
            </summary>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Hierarchy.DisableLevel">
            <summary>
            Obsolete. Use <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/>
            </summary>
        </member>
        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreated">
            <summary>
            Event used to notify that a logger has been created.
            </summary>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
            <summary>
            Get the root of this hierarchy.
            </summary>
        </member>
        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
            <summary>
            Set the default LoggerFactory instance.
            </summary>
        </member>
        <member name="T:log4net.Repository.Hierarchy.LoggerKey">
            <summary>
            LoggerKey is heavily used internally to accelerate hash table searches.
            </summary>
        </member>
        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">
            <summary>
            Summary description for ProvisionNode.
            ProvisionNodes are used in the Hierarchy when
            there is no specified logger for that node.
            </summary>
        </member>
        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">
            <summary>
            Construct new node with specified child logger
            </summary>
            <param name="log">a child logger to add to this node</param>
        </member>
        <member name="T:log4net.Repository.Hierarchy.RootLogger">
            <summary>
            RootLogger sits at the top of the logger hierarchy.
            </summary>
            <remarks>
            <para>RootLogger sits at the top of the logger hierarchy. It is a
            regular logger except that it provides several guarantees.</para>

            <para>First, it cannot be assigned a <c>null</c>
            level. Second, since root logger cannot have a parent, the
            <see cref="M:log4net.Repository.Hierarchy.RootLogger.GetEffectiveLevel"/> method always returns the value of the
            level field without walking the hierarchy.</para>
            </remarks>
        </member>
        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.spi.Level)">
            <summary>
            The root logger names itself as "root". However, the root
            logger cannot be retrieved by name.
            </summary>
            <param name="level"></param>
        </member>
        <member name="M:log4net.Repository.Hierarchy.RootLogger.GetEffectiveLevel">
            <summary>
            Return the assigned level value without walking the logger hierarchy
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">
            <summary>
            Setting a null value to the level of the root logger
            may have catastrophic results. We prevent this here.
            </summary>
        </member>
        <member name="T:log4net.spi.DefaultRepositorySelector">
            <summary>
            The default implementation of the <see cref="T:log4net.spi.IRepositorySelector"/> interface
            </summary>
            <remarks>
            Uses attributes defined on the calling assembly to determine how to
            configure the hierarchy for the domain.
            </remarks>
        </member>
        <member name="T:log4net.spi.IRepositorySelector">
            <summary>
            Interface used my the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.
            </summary>
            <remarks>
            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.spi.IRepositorySelector"/> to specify the policy for
            selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> to return to the caller.
            </remarks>
        </member>
        <member name="M:log4net.spi.IRepositorySelector.GetRepository(System.Reflection.Assembly)">
            <summary>
            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
            </summary>
            <param name="assembly">the assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
            <remarks>
            <para>Lookup the <see cref="T:log4net.Repository.ILoggerRepository"/> for the
            <paramref name="assembly"/> specified.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.IRepositorySelector.GetRepository(System.String)">
            <summary>
            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified domain
            </summary>
            <param name="domain">the domain to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain</returns>
            <remarks>
            <para>Lookup the <see cref="T:log4net.Repository.ILoggerRepository"/> for the
            <paramref name="domain"/> specified.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
            <summary>
            Create a new repository for the assembly specified
            </summary>
            <param name="assembly">the assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>the repository created</returns>
            <remarks>
            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
            specified such that a call to <see cref="M:log4net.spi.IRepositorySelector.GetRepository(System.Reflection.Assembly)"/> with the
            same assembly specified will return the same repository instance.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.IRepositorySelector.CreateRepository(System.String,System.Type)">
            <summary>
            Create a new repository for the domain specified
            </summary>
            <param name="domain">the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>the repository created</returns>
            <remarks>
            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
            specified such that a call to <see cref="M:log4net.spi.IRepositorySelector.GetRepository(System.String)"/> with the
            same domain specified will return the same repository instance.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.IRepositorySelector.GetAllRepositories">
            <summary>
            Get the list of currently defined repositories
            </summary>
            <returns>An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances
            created by this <see cref="T:log4net.spi.IRepositorySelector"/>.</returns>
            <remarks>
            <para>Get the list of currently defined repositories</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.#ctor(System.Type)">
            <summary>
            Create a new repository selector
            </summary>
            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">
            <summary>
            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly
            </summary>
            <param name="assembly">the assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>
            <remarks>
            <para>The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
            the domain to create can be overriden by specifying the
            <see cref="T:log4net.Config.DomainAttribute"/> attribute on the <paramref name="assembly"/>.
            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> implementation
            of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the domain.</para>

            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automaticaly
            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
            the <paramref name="assembly"/>.</para>
            </remarks>
            <exception cref="T:System.ArgumentNullException">throw if <paramref name="assembly"/> is null</exception>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.GetRepository(System.String)">
            <summary>
            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified domain
            </summary>
            <param name="domain">the domain to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain</returns>
            <exception cref="T:System.ArgumentNullException">throw if <paramref name="domain"/> is null</exception>
            <exception cref="T:log4net.spi.LogException">throw if the <paramref name="domain"/> does not exist</exception>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">
            <summary>
            Create a new repository for the assembly specified
            </summary>
            <param name="assembly">the assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <returns>the repository created</returns>
            <remarks>
            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
            specified such that a call to <see cref="M:log4net.spi.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)"/> with the
            same assembly specified will return the same repository instance.</para>

            <para>The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and
            the domain to create can be overriden by specifying the
            <see cref="T:log4net.Config.DomainAttribute"/> attribute on the <paramref name="assembly"/>.
            The default values are to use the <paramref name="repositoryType"/> implementation
            of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the
            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the domain.</para>

            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automaticaly
            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on
            the <paramref name="assembly"/>.</para>

            <para>If a repository for the <paramref name="assembly"/> already exists
            that repository will be returned. An error will not be raised and that
            repository may be of a different type to that specified in <paramref name="repositoryType"/>.
            Also the <see cref="T:log4net.Config.DomainAttribute"/> attribute on the
            assembly may be used to override the repository type specified in
            <paramref name="repositoryType"/>.
            </para>
            </remarks>
            <exception cref="T:System.ArgumentNullException">throw if <paramref name="assembly"/> is null</exception>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">
            <summary>
            Create a new repository for the domain specified
            </summary>
            <param name="domain">the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>
            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.
            If this param is null then the default repsoitory type is used.</param>
            <returns>the repository created</returns>
            <remarks>
            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
            specified such that a call to <see cref="M:log4net.spi.DefaultRepositorySelector.GetRepository(System.String)"/> with the
            same domain specified will return the same repository instance.
            </remarks>
            <exception cref="T:System.ArgumentNullException">throw if <paramref name="domain"/> is null</exception>
            <exception cref="T:log4net.spi.LogException">throw if the <paramref name="domain"/> already exists</exception>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.GetAllRepositories">
            <summary>
            Copy the list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects
            </summary>
            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">
            <summary>
            Get the domain and repository type for the specified assembly
            </summary>
            <param name="assembly">the assembly that has a <see cref="T:log4net.Config.DomainAttribute"/></param>
            <param name="domain">in/out param to hold the domain to use for the assembly, caller should set this to the default value before calling</param>
            <param name="repositoryType">in/out param to hold the type of the repository to create for the domain, caller should set this to the default value before calling</param>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.GetDefaultDomainNameForAssembly(System.Reflection.Assembly)">
            <summary>
            Get the default domain name to use for the assembly specified
            </summary>
            <param name="assembly">the assembly to get the default domain name for</param>
            <returns>the default domain name to use for the assembly</returns>
        </member>
        <member name="M:log4net.spi.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
            <summary>
            Configure the repository using infomation from the assembly
            </summary>
            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>
            attributes which define the configuration for the repository</param>
            <param name="repository">the repository to configure</param>
        </member>
        <member name="T:log4net.spi.ErrorCodes">
            <summary>
            Defined error codes that can be passed to the <see cref="M:log4net.spi.IErrorHandler.Error(System.String,System.Exception,log4net.spi.ErrorCodes)"/> method.
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.GENERIC_FAILURE">
            <summary>
            A general error
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.WRITE_FAILURE">
            <summary>
            Error while writing output
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.FLUSH_FAILURE">
            <summary>
            Failed to flush file
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.CLOSE_FAILURE">
            <summary>
            Failed to close file
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.FILE_OPEN_FAILURE">
            <summary>
            Unable to open output file
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.MISSING_LAYOUT">
            <summary>
            No layout specified
            </summary>
        </member>
        <member name="F:log4net.spi.ErrorCodes.ADDRESS_PARSE_FAILURE">
            <summary>
            Failed to parse address
            </summary>
        </member>
        <member name="T:log4net.spi.ITriggeringEventEvaluator">
            <summary>
            Implementions of this interface allow certain appenders to decide
            when to perform an appender specific action.
            </summary>
            <remarks>
            Implementions of this interface allow certain appenders to decide
            when to perform an appender specific action.
            </remarks>
        </member>
        <member name="M:log4net.spi.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)">
            <summary>
            Is this the triggering event?
            </summary>
            <param name="loggingEvent">The event to check</param>
            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
            <remarks>
            Return <c>true</c> if this event triggers the action
            </remarks>
        </member>
        <member name="T:log4net.spi.Level">
            <summary>
            Defines the set of levels recognised by the system.
            </summary>
            <remarks>
            <para>Defines the set of levels recognised by the system.</para>

            <para>The predefined set of levels recognised by the system are
            <see cref="F:log4net.spi.Level.OFF"/>, <see cref="F:log4net.spi.Level.FATAL"/>, <see cref="F:log4net.spi.Level.ERROR"/>,
            <see cref="F:log4net.spi.Level.WARN"/>, <see cref="F:log4net.spi.Level.INFO"/>, <see cref="F:log4net.spi.Level.DEBUG"/> and
            <see cref="F:log4net.spi.Level.ALL"/>.</para>

            <para>The Level class is sealed. You cannot extend this class.
            To add custom levels the <see cref="M:log4net.spi.Level.Create(System.Int32,System.String)"/> method
            should be called. This will define the level and add it to
            the internal pool of levels.</para>
            </remarks>
        </member>
        <member name="F:log4net.spi.Level.OFF_INT">
            <summary>
            the level assigned to off
            </summary>
        </member>
        <member name="F:log4net.spi.Level.FATAL_INT">
            <summary>
            the level assigned to fatal
            </summary>
        </member>
        <member name="F:log4net.spi.Level.ERROR_INT">
            <summary>
            the level assigned to error
            </summary>
        </member>
        <member name="F:log4net.spi.Level.WARN_INT">
            <summary>
            the level assigned to warn
            </summary>
        </member>
        <member name="F:log4net.spi.Level.INFO_INT">
            <summary>
            the level assigned to info
            </summary>
        </member>
        <member name="F:log4net.spi.Level.DEBUG_INT">
            <summary>
            the level assigned to debug
            </summary>
        </member>
        <member name="F:log4net.spi.Level.ALL_INT">
            <summary>
            the level assigned to all
            </summary>
        </member>
        <member name="F:log4net.spi.Level.m_internPool">
            <summary>
            Hashtable to hold the intern pool for Levels.
            This is a mapping between level (int) and Level
            </summary>
            <remarks>
            This must be the first static member in this class
            because the members are initialised in order.
            </remarks>
        </member>
        <member name="F:log4net.spi.Level.OFF">
            <summary>
            The <c>OFF</c> level designates a higher level than all the rest.
            </summary>
        </member>
        <member name="F:log4net.spi.Level.FATAL">
            <summary>
            The <c>FATAL</c> level designates very severe error events that will presumably lead the application to abort.
            </summary>
        </member>
        <member name="F:log4net.spi.Level.ERROR">
            <summary>
            The <c>ERROR</c> level designates error events that might still allow the application to continue running.
            </summary>
        </member>
        <member name="F:log4net.spi.Level.WARN">
            <summary>
            The <c>WARN</c> level designates potentially harmful situations.
            </summary>
        </member>
        <member name="F:log4net.spi.Level.INFO">
            <summary>
            The <c>INFO</c> level designates informational messages that highlight the progress of the application at coarse-grained level.
            </summary>
        </member>
        <member name="F:log4net.spi.Level.DEBUG">
            <summary>
            The <c>DEBUG</c> level designates fine-grained informational events that are most useful to debug an application.
            </summary>
        </member>
        <member name="F:log4net.spi.Level.ALL">
            <summary>
            The <c>ALL</c> level designates the lowest level possible.
            </summary>
        </member>
        <member name="M:log4net.spi.Level.Intern(log4net.spi.Level)">
            <summary>
            Get an instance of Level from the intern pool
            </summary>
            <param name="level">the equivilent level to get from the pool</param>
            <returns>a Level from the pool</returns>
            <remarks>
            If there is an equivalent Level in the intern pool then
            it is returned, otherwise the argument level if added
            to the pool and returned.
            </remarks>
        </member>
        <member name="M:log4net.spi.Level.Create(System.Int32,System.String)">
            <summary>
            Create a new Level and add it to the pool
            </summary>
            <param name="level">the level value to give to the Level</param>
            <param name="levelStr">the string to display for the Level</param>
            <returns>the Level from the intern pool with the level specified</returns>
        </member>
        <member name="M:log4net.spi.Level.#ctor(System.Int32,System.String)">
            <summary>
            Instantiate a level object.
            </summary>
            <param name="level"></param>
            <param name="levelStr"></param>
        </member>
        <member name="M:log4net.spi.Level.ToString">
            <summary>
            Returns the string representation of this level.
            </summary>
            <returns></returns>
        </member>
        <member name="M:log4net.spi.Level.Equals(System.Object)">
            <summary>
            Override Equals to compare the levels of
            Level objects. Defers to base class if
            the target object is not a Level.
            </summary>
            <param name="o">The object to compare against</param>
            <returns>true if the objects are equal</returns>
        </member>
        <member name="M:log4net.spi.Level.GetHashCode">
            <summary>
            Returns a hash code that is sutable for use in a hashtree etc
            </summary>
            <returns>the hash of this object</returns>
        </member>
        <member name="M:log4net.spi.Level.op_GreaterThan(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Operator greater than that compares Levels
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is greater than the right hand side</returns>
        </member>
        <member name="M:log4net.spi.Level.op_LessThan(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Operator less than that compares Levels
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is less than the right hand side</returns>
        </member>
        <member name="M:log4net.spi.Level.op_GreaterThanOrEqual(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Operator greater than or equal that compares Levels
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is greater than or equal to the right hand side</returns>
        </member>
        <member name="M:log4net.spi.Level.op_LessThanOrEqual(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Operator less than or equal that compares Levels
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is less than or equal to the right hand side</returns>
        </member>
        <member name="M:log4net.spi.Level.op_Equality(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Operator equals that compares Levels
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is equal to the right hand side</returns>
        </member>
        <member name="M:log4net.spi.Level.op_Inequality(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Operator not equals that compares Levels
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is not equal to the right hand side</returns>
        </member>
        <member name="M:log4net.spi.Level.Compare(log4net.spi.Level,log4net.spi.Level)">
            <summary>
            Compares two specified <see cref="T:log4net.spi.Level"/> values.
            </summary>
            <param name="l">A <see cref="T:log4net.spi.Level"/></param>
            <param name="r">A <see cref="T:log4net.spi.Level"/></param>
            <returns>A signed number indicating the relative values of <c>l</c> and <c>r</c>.</returns>
            <remarks>
            Less than zero: <c>l</c> is less than <c>r</c>.
            Zero: <c>l</c> and <c>r</c> are equal.
            Greater than zero: <c>l</c> is greater than <c>r</c>.
            </remarks>
        </member>
        <member name="M:log4net.spi.Level.CompareTo(System.Object)">
            <summary>
            Compares this instance to a specified <see cref="T:System.Object"/>
            </summary>
            <param name="r">An <see cref="T:System.Object"/> or a null reference</param>
            <returns>A signed number indicating the relative values of this instance and <c>r</c>.</returns>
            <remarks>
            Less than zero: this instance is less than <c>r</c>.
            Zero: this instance and <c>r</c> are equal.
            Greater than zero: this instance is greater than <c>r</c>.
            Any instance of <see cref="T:log4net.spi.Level"/>, regardless of its value,
            is considered greater than a null reference.
            </remarks>
        </member>
        <member name="M:log4net.spi.Level.Parse(System.String)">
            <summary>
            Convert the string passed as argument to a level. If the
            conversion fails, then this method returns <see cref="F:log4net.spi.Level.DEBUG"/>.
            </summary>
            <param name="value">The string to parse into a Level</param>
            <returns>The Level represented by the string argument</returns>
        </member>
        <member name="M:log4net.spi.Level.Parse(System.Int32)">
            <summary>
            Convert an integer passed as argument to a level. If the
            conversion fails, then this method returns <see cref="F:log4net.spi.Level.DEBUG"/>.
            </summary>
            <param name="value">The int to convert to a Level</param>
            <returns>The Level represented by the argument</returns>
        </member>
        <member name="M:log4net.spi.Level.Parse(System.Int32,log4net.spi.Level)">
            <summary>
            Convert an integer passed as argument to a level. If the
            conversion fails, then this method returns the specified default.
            </summary>
            <param name="value">The value to convert to a Prority</param>
            <param name="defaultLevel">The default Level value to use</param>
            <returns>The Level represented by the Argument</returns>
        </member>
        <member name="M:log4net.spi.Level.Parse(System.String,log4net.spi.Level)">
            <summary>
            Convert the string passed as argument to a level. If the
            conversion fails, then this method returns the value of
            <c>defaultLevel</c>.
            </summary>
            <param name="value">The string to parse</param>
            <param name="defaultLevel">the default Level to use</param>
            <returns>The Level represented by the argument</returns>
        </member>
        <member name="P:log4net.spi.Level.AllLevels">
            <summary>
            Return all possible levels as an array of Level objects.
            </summary>
            <returns>all possible levels as an array of Level objects</returns>
        </member>
        <member name="T:log4net.spi.LevelConverter">
            <summary>
            Implementation of <see cref="T:System.ComponentModel.TypeConverter"/> that converts a <see cref="T:log4net.spi.Level"/>
            instance to and from a string.
            </summary>
        </member>
        <member name="M:log4net.spi.LevelConverter.CanConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Type)">
            <summary>
            Overrides the CanConvertFrom method of TypeConverter.
            The ITypeDescriptorContext interface provides the context for the
            conversion. Typically this interface is used at design time to
            provide information about the design-time container.
            </summary>
            <param name="context"></param>
            <param name="sourceType"></param>
            <returns>true if the source is a string</returns>
        </member>
        <member name="M:log4net.spi.LevelConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)">
            <summary>
            Overrides the ConvertFrom method of TypeConverter.
            </summary>
            <param name="context"></param>
            <param name="culture"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:log4net.spi.LevelConverter.ConvertTo(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object,System.Type)">
            <summary>
            Overrides the ConvertTo method of TypeConverter.
            </summary>
            <param name="context"></param>
            <param name="culture"></param>
            <param name="value"></param>
            <param name="destinationType"></param>
            <returns></returns>
        </member>
        <member name="T:log4net.spi.LevelEvaluator">
            <summary>
            An evaluator that triggers at a theshold level
            </summary>
            <remarks>
            <para>This evaluator will trigger if the level of the event
            passed to <see cref="M:log4net.spi.LevelEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)"/>
            is equal to or greater than the <see cref="P:log4net.spi.LevelEvaluator.Threshold"/>
            level.</para>
            </remarks>
        </member>
        <member name="F:log4net.spi.LevelEvaluator.m_threshold">
            <summary>
            The threshold for triggering
            </summary>
        </member>
        <member name="M:log4net.spi.LevelEvaluator.#ctor">
            <summary>
            Create a new evaluator using the <see cref="F:log4net.spi.Level.OFF"/> threshold.
            </summary>
            <remarks>
            <para>Create a new evaluator using the <see cref="F:log4net.spi.Level.OFF"/> threshold.</para>

            <para>This evaluator will trigger if the level of the event
            passed to <see cref="M:log4net.spi.LevelEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)"/>
            is equal to or greater than the <see cref="P:log4net.spi.LevelEvaluator.Threshold"/>
            level.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.LevelEvaluator.#ctor(log4net.spi.Level)">
            <summary>
            Create a new evaluator using the specified <see cref="T:log4net.spi.Level"/> threshold.
            </summary>
            <param name="threshold">the threshold to trigger at</param>
            <remarks>
            <para>Create a new evaluator using the specified <see cref="T:log4net.spi.Level"/> threshold.</para>

            <para>This evaluator will trigger if the level of the event
            passed to <see cref="M:log4net.spi.LevelEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)"/>
            is equal to or greater than the <see cref="P:log4net.spi.LevelEvaluator.Threshold"/>
            level.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.LevelEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)">
            <summary>
            Is this <paramref name="loggingEvent"/> the triggering event?
            </summary>
            <param name="loggingEvent">The event to check</param>
            <returns>This method returns <c>true</c>, if the event level
            is equal or higher than the <see cref="P:log4net.spi.LevelEvaluator.Threshold"/>.
            Otherwise it returns <c>false</c></returns>
            <remarks>
            <para>This evaluator will trigger if the level of the event
            passed to <see cref="M:log4net.spi.LevelEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)"/>
            is equal to or greater than the <see cref="P:log4net.spi.LevelEvaluator.Threshold"/>
            level.</para>
            </remarks>
        </member>
        <member name="P:log4net.spi.LevelEvaluator.Threshold">
            <summary>
            the threshold to trigger at
            </summary>
            <value>
            The <see cref="T:log4net.spi.Level"/> that will cause this evaluator to trigger
            </value>
            <remarks>
            <para>This evaluator will trigger if the level of the event
            passed to <see cref="M:log4net.spi.LevelEvaluator.IsTriggeringEvent(log4net.spi.LoggingEvent)"/>
            is equal to or greater than the <see cref="P:log4net.spi.LevelEvaluator.Threshold"/>
            level.</para>
            </remarks>
        </member>
        <member name="T:log4net.spi.LocationInfo">
            <summary>
            The internal representation of caller location information.
            </summary>
        </member>
        <member name="F:log4net.spi.LocationInfo.NA">
            <summary>
            When location information is not available the constant
            <c>NA</c> is returned. Current value of this string
            constant is <b>?</b>.
            </summary>
        </member>
        <member name="M:log4net.spi.LocationInfo.#ctor(System.String)">
            <summary>
            Instantiate location information based on the current thread
            </summary>
            <param name="fqnOfCallingClass"></param>
        </member>
        <member name="M:log4net.spi.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">
            <summary>
            Create LocationInfo with specified data
            </summary>
            <param name="className">the fully qualified class name</param>
            <param name="methodName">the method name</param>
            <param name="fileName">the file name</param>
            <param name="lineNumber">the line number of the method within the fime</param>
        </member>
        <member name="P:log4net.spi.LocationInfo.ClassName">
            <summary>
            Return the fully qualified class name of the caller making the logging request.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LocationInfo.FileName">
            <summary>
            Return the file name of the caller.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LocationInfo.LineNumber">
            <summary>
            Returns the line number of the caller.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LocationInfo.MethodName">
            <summary>
            Returns the method name of the caller.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LocationInfo.FullInfo">
            <summary>
            All available caller information, in the format
            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>
            </summary>
            <returns></returns>
        </member>
        <member name="T:log4net.spi.LogException">
            <summary>
            Exception base type for log4net
            </summary>
            <remarks>
            <para>This type extends <see cref="T:System.ApplicationException"/>. It
            does not add any new functionality but does differentiate the
            type of exception being thrown.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.LogException.#ctor">
            <summary>
            Empty contructor
            </summary>
            <remarks>
            Empty constructor
            </remarks>
        </member>
        <member name="M:log4net.spi.LogException.#ctor(System.String)">
            <summary>
            Constructor with <paramref name="message"/> argument
            </summary>
            <param name="message">a message to include with the exception</param>
            <remarks>
            Constructor with <paramref name="message"/> argument
            </remarks>
        </member>
        <member name="M:log4net.spi.LogException.#ctor(System.String,System.Exception)">
            <summary>
            Constructor with <paramref name="message"/> and <paramref name="innerException"/> arguments
            </summary>
            <param name="message">a message to include with the exception</param>
            <param name="innerException">a nested exception to include</param>
            <remarks>
            Constructor with <paramref name="message"/> and <paramref name="innerException"/> arguments
            </remarks>
        </member>
        <member name="M:log4net.spi.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Serialisation constructor
            </summary>
            <param name="info"></param>
            <param name="context"></param>
        </member>
        <member name="T:log4net.spi.LoggingEventData">
            <summary>
            Portable data structure used by <see cref="T:log4net.spi.LoggingEvent"/>
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.LoggerName">
            <summary>
            The logger name.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.Level">
            <summary>
            Level of logging event. Level cannot be serializable
            because it is a flyweight.  Due to its special seralization it
            cannot be declared final either.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.NDC">
            <summary>
            The nested diagnostic context (NDC) of logging event.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.MDC">
            <summary>
            The local cache of the MDC dictionary
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.Message">
            <summary>
            The application supplied message of logging event.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.ThreadName">
            <summary>
            The name of thread in which this logging event was generated
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.TimeStamp">
            <summary>
            The time the event was logged
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.LocationInfo">
            <summary>
            Location information for the caller.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.UserName">
            <summary>
            String representation of the user's windows name,
            like DOMAIN\username
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEventData.ExceptionString">
            <summary>
            The string representation of the exception
            </summary>
        </member>
        <member name="T:log4net.spi.LoggingEvent">
            <summary>
            The internal representation of logging events.
            </summary>
            <remarks>
            <para>When an affirmative decision is made to log then a
            <see cref="T:log4net.spi.LoggingEvent"/> instance is created. This instance
            is passed around to the different log4net components.</para>

            <para>This class is of concern to those wishing to extend log4net.</para>

            <para>Some of the values in instances of <see cref="T:log4net.spi.LoggingEvent"/>
            are considered volatile, that is the values are correct at the
            time the event is delivered to appenders, but will not be consistant
            at any time afterwards. If an event is to be stored and then processed
            at a later time these volatile values must be fixed by calling
            <see cref="M:log4net.spi.LoggingEvent.FixVolatileData"/>. There is a performance penalty
            for incured by calling <see cref="M:log4net.spi.LoggingEvent.FixVolatileData"/> but it
            is essential to maintaining data consistency.</para>
            </remarks>
        </member>
        <member name="F:log4net.spi.LoggingEvent.s_startTime">
            <summary>
            Stores the time when this class is loaded
            </summary>
            <remarks>
            This is used to provide times relative to the
            application start.
            </remarks>
        </member>
        <member name="F:log4net.spi.LoggingEvent.m_data">
            <summary>
            Field to hold internal logging event data
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEvent.m_fqnOfLoggerClass">
            <summary>
            Fully qualified name of the calling logger class.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEvent.m_message">
            <summary>
            The application supplied message of logging event.
            </summary>
        </member>
        <member name="F:log4net.spi.LoggingEvent.m_thrownException">
            <summary>
            Hold the exception thown if nessasary
            </summary>
            <remarks>
            This is not serialised. The <c>m_exceptionStrRep</c>
            is serialised instead.
            </remarks>
        </member>
        <member name="F:log4net.spi.LoggingEvent.m_repository">
            <summary>
            The repository that generated the logging event
            </summary>
            <remarks>
            This is not serialised.
            </remarks>
        </member>
        <member name="M:log4net.spi.LoggingEvent.#ctor(System.String,log4net.Repository.ILoggerRepository,System.String,log4net.spi.Level,System.Object,System.Exception)">
            <summary>
            Instantiate a LoggingEvent from the supplied parameters.
            </summary>
            <param name="fqnOfLoggerClass"></param>
            <param name="repository">The repository this event is logged in</param>
            <param name="loggerName">The name of the logger of this event</param>
            <param name="level">The level of this event</param>
            <param name="message">The message of this event</param>
            <param name="throwable">The throwable of this event</param>
            <remarks>
            <para>Except <see cref="P:log4net.spi.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.spi.LoggingEvent.Level"/> and <see cref="P:log4net.spi.LoggingEvent.LoggerName"/>
            all the other fields of <c>LoggingEvent</c> are filled when actually needed. Call
            <see cref="M:log4net.spi.LoggingEvent.FixVolatileData"/> to cache all data localy
            to prevent inconsistancies.</para>

            <para>This method is called by the log4net framework
            to create a logging event.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Deserialization constructor
            </summary>
            <param name="info"></param>
            <param name="context"></param>
        </member>
        <member name="M:log4net.spi.LoggingEvent.#ctor(log4net.spi.LoggingEventData)">
            <summary>
            Construct a LoggingEvent using specific data
            </summary>
            <param name="data">data used to initialise the logging event</param>
            <remarks>
            <para>This constructor is provided to allow a LoggingEvent
            to be created independantly of the log4net framework. This can
            be usefull if you require a custom serialisation scheme.</para>

            <para>Use the <see cref="M:log4net.spi.LoggingEvent.GetLoggingEventData"/> method to
            obtain a <see cref="T:log4net.spi.LoggingEventData"/>.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Serialise this object into the <c>SerializationInfo</c> provided
            </summary>
            <param name="info"></param>
            <param name="context"></param>
        </member>
        <member name="M:log4net.spi.LoggingEvent.GetLoggingEventData">
            <summary>
            Get the portable data for this LoggingEvent
            </summary>
            <returns>the <see cref="T:log4net.spi.LoggingEventData"/> for this event</returns>
            <remarks>
            <para>A <see cref="T:log4net.spi.LoggingEvent"/> can be constructed using a
            <see cref="T:log4net.spi.LoggingEventData"/>.</para>
            </remarks>
        </member>
        <member name="M:log4net.spi.LoggingEvent.LookupMappedContext(System.String)">
            <summary>
            Lookup the kep specified in the <see cref="T:log4net.MDC"/>
            </summary>
            <param name="key">the key to lookup</param>
            <returns>the value associated with the key, or <c>null</c> if the key was not found</returns>
        </member>
        <member name="M:log4net.spi.LoggingEvent.GetExceptionStrRep">
            <summary>
            Return this event's exception's string representaion.
            </summary>
            <returns></returns>
        </member>
        <member name="M:log4net.spi.LoggingEvent.FixVolatileData">
            <summary>
            Fix member variables that hold volatile data.
            </summary>
            <remarks>
            <para>Some of the values in instances of <see cref="T:log4net.spi.LoggingEvent"/>
            are considered volatile, that is the values are correct at the
            time the event is delivered to appenders, but will not be consistant
            at any time afterwards. If an event is to be stored and then processed
            at a later time these volatile values must be fixed by calling
            <see cref="M:log4net.spi.LoggingEvent.FixVolatileData"/>. There is a performance penalty
            for incured by calling <see cref="M:log4net.spi.LoggingEvent.FixVolatileData"/> but it
            is essential to maintaining data consistency.</para>
            </remarks>
        </member>
        <member name="P:log4net.spi.LoggingEvent.StartTime">
            <summary>
            Returns the time when the application started, in milliseconds elapsed since 01.01.1970.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LoggingEvent.Level">
            <summary>
            The Level of the logging event
            </summary>
        </member>
        <member name="P:log4net.spi.LoggingEvent.TimeStamp">
            <summary>
            The time of the event
            </summary>
        </member>
        <member name="P:log4net.spi.LoggingEvent.LoggerName">
            <summary>
            The name of the logger that logged the event
            </summary>
        </member>
        <member name="P:log4net.spi.LoggingEvent.LocationInformation">
            <summary>
            Set the location information for this logging event. The collected
            information is cached for future use.
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LoggingEvent.NestedContext">
            <summary>
            Get the text of the <see cref="T:log4net.NDC"/>
            </summary>
            <value>the text of the <see cref="T:log4net.NDC"/></value>
        </member>
        <member name="P:log4net.spi.LoggingEvent.RenderedMessage">
            <summary>
            Get the message (rendered through the RendererMap)
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LoggingEvent.ThreadName">
            <summary>
            Get the name of the current thread.  Returns the thread ID
            when the name is not available
            </summary>
            <returns></returns>
        </member>
        <member name="P:log4net.spi.LoggingEvent.WindowsIdentityName">
            <summary>
            Returns the identity of the current user.

            To improve performance, we could
            cache the string representation of the name, and reuse that
            as long as the identity stayed constant.  Once the identity changed,
            we would need to re-assign and re-render the string.

            However, the GetCurrent call seems to return different objects
            every time...so the current implementation doesn't do this type
            of caching.

            Timing for these operations:

            00:00:00.2031250 sec, 10000 loops, WindowsIdentity.GetCurrent()
            00:00:08.0468750 sec, 10000 loops, WindowsIdentity.GetCurrent().Name.ToString()

            So we could speed things up almost 40 times by caching the ToString
            operation, since the .Name.ToString() takes (8.04-0.20)=7.84375 sec
            </summary>
        </member>
        <member name="P:log4net.spi.LoggingEvent.UserName">
            <summary>
            Returns the identity of the current user.

            To improve performance, we could
            cache the string representation of the name, and reuse that
            as long as the identity stayed constant.  Once the identity changed,
            we would need to re-assign and re-render the string.

            However, the GetCurrent call seems to return different objects
            every time...so the current implementation doesn't do this type
            of caching.

            Timing for these operations:

            00:00:00.2031250 sec, 10000 loops, WindowsIdentity.GetCurrent()
            00:00:08.0468750 sec, 10000 loops, WindowsIdentity.GetCurrent().Name.ToString()

            So we could speed things up almost 40 times by caching the ToString
            operation, since the .Name.ToString() takes (8.04-0.20)=7.84375 sec
            </summary>
        </member>
        <member name="T:log4net.Category">
            <summary>
            <b>Deprecated.</b> See <see cref="T:log4net.ILog"/> and <see cref="T:log4net.LogManager"/>.
            </summary>
            <remarks>
            <para><b>Deprecated.</b></para>
            This class is just a thin wrapper arround <see cref="T:log4net.ILog"/> and
            <see cref="T:log4net.LogManager"/>.
            </remarks>
        </member>
        <member name="M:log4net.Category.#ctor(log4net.ILog)">
            <summary>
            This constructor created a new <see cref="T:log4net.Category"/> instance and
            sets its name.
            </summary>
            <remarks>
            This constructor created a new <see cref="T:log4net.Category"/> instance and
            sets its name.

            <para>It is intended to be used by sub-classes only. You can't
            create loggers directly.</para>
            </remarks>
            <param name="log">the ILog to map to</param>
        </member>
        <member name="M:log4net.Category.Debug(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.DEBUG"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this category is <c>DEBUG</c>
            enabled by comparing the level of this category with the
            <see cref="F:log4net.spi.Level.DEBUG"/> level. If this category is
            <c>DEBUG</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this category and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Category.Debug(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Category.Debug(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>DEBUG</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Category.Debug(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Category.Debug(System.Object)"/>
        </member>
        <member name="M:log4net.Category.Info(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.INFO"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this category is <c>INFO</c>
            enabled by comparing the level of this category with the
            <see cref="F:log4net.spi.Level.INFO"/> level. If this category is
            <c>INFO</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this category and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Category.Info(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Category.Info(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>INFO</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Category.Info(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Category.Info(System.Object)"/>
        </member>
        <member name="M:log4net.Category.Warn(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.WARN"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this category is <c>WARN</c>
            enabled by comparing the level of this category with the
            <see cref="F:log4net.spi.Level.WARN"/> level. If this category is
            <c>WARN</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this category and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Category.Warn(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Category.Warn(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>WARN</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Category.Warn(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Category.Warn(System.Object)"/>
        </member>
        <member name="M:log4net.Category.Error(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.ERROR"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this category is <c>ERROR</c>
            enabled by comparing the level of this category with the
            <see cref="F:log4net.spi.Level.ERROR"/> level. If this category is
            <c>ERROR</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this category and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Category.Error(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Category.Error(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>ERROR</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Category.Error(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Category.Error(System.Object)"/>
        </member>
        <member name="M:log4net.Category.Fatal(System.Object)">
            <summary>
            Log a message object with the <see cref="F:log4net.spi.Level.FATAL"/> level.
            </summary>
            <remarks>
            <para>This method first checks if this category is <c>FATAL</c>
            enabled by comparing the level of this category with the
            <see cref="F:log4net.spi.Level.FATAL"/> level. If this category is
            <c>FATAL</c> enabled, then it converts the message object
            (passed as parameter) to a string by invoking the appropriate
            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then proceeds to call all the
            registered appenders in this category and also higher in the
            hierarchy depending on the value of the additivity flag.</para>

            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this
            method will print the name of the <see cref="T:System.Exception"/> but no
            stack trace. To print a stack trace use the
            <see cref="M:log4net.Category.Fatal(System.Object,System.Exception)"/> form instead.</para>
            </remarks>
            <param name="message">the message object to log</param>
        </member>
        <member name="M:log4net.Category.Fatal(System.Object,System.Exception)">
            <summary>
            Log a message object with the <c>FATAL</c> level including
            the stack trace of the <see cref="T:System.Exception"/> <paramref name="t"/> passed
            as a parameter.
            </summary>
            <param name="message">the message object to log</param>
            <param name="t">the exception to log, including its stack trace</param>
            <remarks>
            See the <see cref="M:log4net.Category.Fatal(System.Object)"/> form for more detailed information.
            </remarks>
            <seealso cref="M:log4net.Category.Fatal(System.Object)"/>
        </member>
        <member name="M:log4net.Category.Exists(System.String)">
            <summary>
            Check if the named category exists.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.Exists(System.String)"/> instead.</b></para>
            </summary>
            <param name="name">The fully qualified category name to look for</param>
            <remarks>
            If the named category exists (in the default hierarchy) then it
            returns a reference to the category, otherwise it returns
            <c>null</c>.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.Exists(System.String)"/> instead.</b></para>
            </remarks>
            <returns>The category found, or null</returns>
        </member>
        <member name="M:log4net.Category.GetCurrentLoggers">
            <summary>
            Returns all the currently defined loggers in the default
            hierarchy as an <see cref="T:System.Collections.IEnumerator"/>.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetCurrentLoggers"/> instead.</b></para>
            </summary>
            <remarks>
            The root category is <b>not</b> included in the returned
            enumeration.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetCurrentLoggers"/> instead.</b></para>
            </remarks>
            <returns>All the defined loggers</returns>
        </member>
        <member name="M:log4net.Category.GetInstance(System.String)">
            <summary>
            Get or create the named category.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetLogger(System.String)"/> instead.</b></para>
            </summary>
            <remarks>
            Retrieve a category with named as the <c>name</c>
            parameter. If the named category already exists, then the
            existing instance will be reutrned. Otherwise, a new instance is
            created.
            <para>By default, loggers do not have a set level but inherit
            it from the hierarchy. This is one of the central features of
            log4net.</para>
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetLogger(System.String)"/> instead.</b></para>
            </remarks>
            <param name="name">The name of the category to retrieve.</param>
            <returns>the category with the name specified</returns>
        </member>
        <member name="M:log4net.Category.GetInstance(System.Type)">
            <summary>
            Shorthand for <c>getInstance(clazz.FullName)</c>.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetLogger(System.Type)"/> instead.</b></para>
            </summary>
            <param name="clazz">The name of <c>clazz</c> will
            be used as the name of the category to retrieve.</param>
            <remarks>
            Get a log category using the fully qualified class name
            for the Type specified.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetLogger(System.Type)"/> instead.</b></para>
            </remarks>
            <returns>the category with the name specified</returns>
        </member>
        <member name="M:log4net.Category.Shutdown">
            <summary>
            Shutdown this hierarchy.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.Shutdown"/> instead.</b></para>
            </summary>
            <remarks>
            Calling this method will <b>safely</b> close and remove all
            appenders in all the loggers including root contained in the
            default hierarchy.

            <para>Some appenders need to be closed before the application exists.
            Otherwise, pending logging events might be lost.</para>

            <para>The <c>shutdown</c> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a category
            and again to a nested appender.</para>
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.Shutdown"/> instead.</b></para>
            </remarks>
        </member>
        <member name="P:log4net.Category.IsDebugEnabled">
            <summary>
            Check if this category is enabled for the <c>DEBUG</c>
            level.
            </summary>
            <value>
            True if this category is enabled for <c>DEBUG</c> events.
            </value>
            <remarks>
            <para>This function is intended to lessen the computational cost of
            disabled log debug statements.</para>

            <para> For some <c>cat</c> Category object, when you write:</para>
            <code>
            cat.Debug("This is entry number: " + i );
            </code>

            <para>You incur the cost constructing the message, concatenation in
            this case, regardless of whether the message is logged or not.</para>

            <para>If you are worried about speed, then you should write:</para>
            <code>
            if (cat.IsDebugEnabled())
            {
                cat.Debug("This is entry number: " + i );
            }
            </code>

            <para>This way you will not incur the cost of parameter
            construction if debugging is disabled for <c>cat</c>. On
            the other hand, if the <c>cat</c> is debug enabled, you
            will incur the cost of evaluating whether the category is debug
            enabled twice. Once in <c>IsDebugEnabled</c> and once in
            the <c>Debug</c>.  This is an insignificant overhead
            since evaluating a category takes about 1% of the time it
            takes to actually log.</para>
            </remarks>
            <returns><c>true</c> if this category is debug enabled, <c>false</c> otherwise</returns>
        </member>
        <member name="P:log4net.Category.IsInfoEnabled">
            <summary>
            Check if this category is enabled for the INFO <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this category is enabled for <c>INFO</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Category.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this category is enabled for the <c>INFO</c> level.</returns>
            <seealso cref="P:log4net.Category.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Category.IsWarnEnabled">
            <summary>
            Check if this category is enabled for the WARN <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this category is enabled for <c>WARN</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Category.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this category is enabled for the <c>WARN</c> level.</returns>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Category.IsErrorEnabled">
            <summary>
            Check if this category is enabled for the ERROR <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this category is enabled for <c>ERROR</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Category.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this category is enabled for the <c>ERROR</c> level.</returns>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Category.IsFatalEnabled">
            <summary>
            Check if this category is enabled for the FATAL <see cref="T:log4net.spi.Level"/>.
            </summary>
            <value>
            True if this category is enabled for <c>FATAL</c> events.
            </value>
            <remarks>
            See <see cref="P:log4net.Category.IsDebugEnabled"/> for more information and examples of using this method.
            </remarks>
            <returns>boolean True if this category is enabled for the <c>FATAL</c> level.</returns>
            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
        </member>
        <member name="P:log4net.Category.DefaultHierarchy">
            <summary>
            Return the default Hierarchy instance.
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetLoggerRepository"/> instead.</b></para>
            </summary>
            <value>The default hierarchy</value>
            <remarks>
            <para><b>Deprecated, call <see cref="M:log4net.LogManager.GetLoggerRepository"/> instead.</b></para>
            </remarks>
        </member>
        <member name="P:log4net.Category.Root">
            <summary>
            Return the root of the default category hierarchy.
            <para><b>Deprecated</b></para>
            </summary>
            <value>
            The Category that is the root of the hierarchy.
            </value>
            <remarks>
            The root category is always instantiated and available. It's
            name is "root".

            <para>Nevertheless, calling <c>Category.GetInstance("root")</c>
            does not retrieve the root category but a category just under root
            named "root".</para>
            <para><b>Deprecated</b></para>
            </remarks>
        </member>
        <member name="T:log4net.LogManager">
            <summary>
            This is the class used by client applications to bind to logger
            instances.
            </summary>
            <remarks>
            See the <see cref="T:log4net.ILog"/> interface for more details.
            </remarks>
            <example>Simple example of logging messages
            <code>
            ILog log = LogManager.GetLogger("application-log");

            log.Info("Application Start");
            log.Debug("This is a debug message");

            if (log.IsDebugEnabled)
            {
                log.Debug("This is another debug message");
            }
            </code>
            </example>
            <seealso cref="T:log4net.ILog"/>
        </member>
        <member name="F:log4net.LogManager.s_repositorySelector">
            <summary>
            Initialise the default repository selector
            </summary>
        </member>
        <member name="M:log4net.LogManager.#cctor">
            <summary>
            Hook the shutdown event
            </summary>
            <remarks>
            Static constructor hoohs up the <see cref="F:System.AppDomain.ProcessExit"/> and
            <see cref="F:System.AppDomain.DomainUnload"/> events. These are used to shutdown
            the log4net system as the application exits.
            </remarks>
        </member>
        <member name="M:log4net.LogManager.#ctor">
            <summary>
            Private constructor to prevent instances. Only static methods should be used.
            </summary>
            <remarks>
            Private constructor to prevent instances. Only static methods should be used.
            </remarks>
        </member>
        <member name="M:log4net.LogManager.GetLoggerRepository">
            <summary>
            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
            </summary>
            <returns>the <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default domain</returns>
            <remarks>
            <para>Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain specified
            by the callers assembly (<see cref="M:System.Reflection.Assembly.GetCallingAssembly"/>).</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">
            <summary>
            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
            </summary>
            <param name="domain">the domain to lookup in</param>
            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
            <remarks>
            <para>Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain specified
            by the <paramref name="domain"/> argument.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">
            <summary>
            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.
            </summary>
            <param name="assembly">the assembly to use to lookup the domain</param>
            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>
            <remarks>
            <para>Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain specified
            by the <paramref name="assembly"/> argument.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.Exists(System.String)">
            <summary>
            Returns the named logger if it exists
            <c>null</c>.
            </summary>
            <remarks>
            <para>If the named logger exists (in the default hierarchy) then it
            returns a reference to the logger, otherwise it returns
            <c>null</c>.</para>
            </remarks>
            <param name="name">The fully qualified logger name to look for</param>
            <returns>The logger found, or null</returns>
        </member>
        <member name="M:log4net.LogManager.Exists(System.String,System.String)">
            <summary>
            Returns the named logger if it exists
            </summary>
            <remarks>
            <para>If the named logger exists (in the specified domain) then it
            returns a reference to the logger, otherwise it returns
            <c>null</c>.</para>
            </remarks>
            <param name="domain">the domain to lookup in</param>
            <param name="name">The fully qualified logger name to look for</param>
            <returns>The logger found, or null</returns>
        </member>
        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">
            <summary>
            Returns the named logger if it exists
            </summary>
            <remarks>
            <para>If the named logger exists (in the specified assembly's domain) then it
            returns a reference to the logger, otherwise it returns
            <c>null</c>.</para>
            </remarks>
            <param name="assembly">the assembly to use to lookup the domain</param>
            <param name="name">The fully qualified logger name to look for</param>
            <returns>The logger found, or null</returns>
        </member>
        <member name="M:log4net.LogManager.GetCurrentLoggers">
            <summary>
            Returns all the currently defined loggers in the default domain.
            </summary>
            <remarks>
            <para>The root logger is <b>not</b> included in the returned array.</para>
            </remarks>
            <returns>All the defined loggers</returns>
        </member>
        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">
            <summary>
            Returns all the currently defined loggers in the specified domain.
            </summary>
            <param name="domain">the domain to lookup in</param>
            <remarks>
            The root logger is <b>not</b> included in the returned array.
            </remarks>
            <returns>All the defined loggers</returns>
        </member>
        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">
            <summary>
            Returns all the currently defined loggers in the specified assembly's domain.
            </summary>
            <param name="assembly">the assembly to use to lookup the domain</param>
            <remarks>
            The root logger is <b>not</b> included in the returned array.
            </remarks>
            <returns>All the defined loggers</returns>
        </member>
        <member name="M:log4net.LogManager.GetLogger(System.String)">
            <summary>
            Retrieve or create a named logger.
            </summary>
            <remarks>
            <para>Retrieve a logger named as the <paramref name="name"/>
            parameter. If the named logger already exists, then the
            existing instance will be reutrned. Otherwise, a new instance is
            created.</para>

            <para>By default, loggers do not have a set level but inherit
            it from the hierarchy. This is one of the central features of
            log4net.</para>
            </remarks>
            <param name="name">The name of the logger to retrieve.</param>
            <returns>the logger with the name specified</returns>
        </member>
        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">
            <summary>
            Retrieve or create a named logger.
            </summary>
            <remarks>
            <para>Retrieve a logger named as the <paramref name="name"/>
            parameter. If the named logger already exists, then the
            existing instance will be reutrned. Otherwise, a new instance is
            created.</para>

            <para>By default, loggers do not have a set level but inherit
            it from the hierarchy. This is one of the central features of
            log4net.</para>
            </remarks>
            <param name="domain">the domain to lookup in</param>
            <param name="name">The name of the logger to retrieve.</param>
            <returns>the logger with the name specified</returns>
        </member>
        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">
            <summary>
            Retrieve or create a named logger.
            </summary>
            <remarks>
            <para>Retrieve a logger named as the <paramref name="name"/>
            parameter. If the named logger already exists, then the
            existing instance will be reutrned. Otherwise, a new instance is
            created.</para>

            <para>By default, loggers do not have a set level but inherit
            it from the hierarchy. This is one of the central features of
            log4net.</para>
            </remarks>
            <param name="assembly">the assembly to use to lookup the domain</param>
            <param name="name">The name of the logger to retrieve.</param>
            <returns>the logger with the name specified</returns>
        </member>
        <member name="M:log4net.LogManager.GetLogger(System.Type)">
            <summary>
            Shorthand for <see cref="M:log4net.LogManager.GetLogger(System.String)"/>.
            </summary>
            <remarks>
            Get the logger for the fully qualifed name of the type specified.
            </remarks>
            <param name="type">The full name of <paramref name="type"/> will
            be used as the name of the logger to retrieve.</param>
            <returns>the logger with the name specified</returns>
        </member>
        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">
            <summary>
            Shorthand for <see cref="M:log4net.LogManager.GetLogger(System.String)"/>.
            </summary>
            <remarks>
            Get the logger for the fully qualifed name of the type specified.
            </remarks>
            <param name="domain">the domain to lookup in</param>
            <param name="type">The full name of <paramref name="type"/> will
            be used as the name of the logger to retrieve.</param>
            <returns>the logger with the name specified</returns>
        </member>
        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">
            <summary>
            Shorthand for <see cref="M:log4net.LogManager.GetLogger(System.String)"/>.
            </summary>
            <remarks>
            Get the logger for the fully qualifed name of the type specified.
            </remarks>
            <param name="assembly">the assembly to use to lookup the domain</param>
            <param name="type">The full name of <paramref name="type"/> will
            be used as the name of the logger to retrieve.</param>
            <returns>the logger with the name specified</returns>
        </member>
        <member name="M:log4net.LogManager.Shutdown">
            <summary>
            Shutdown the log4net system.
            </summary>
            <remarks>
            <para>Calling this method will <b>safely</b> close and remove all
            appenders in all the loggers including root contained in all the
            default repositories.</para>

            <para>Some appenders need to be closed before the application exists.
            Otherwise, pending logging events might be lost.</para>

            <para>The <c>shutdown</c> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a logger
            and again to a nested appender.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.ShutdownRepository">
            <summary>
            Shutdown the default repository.
            </summary>
            <remarks>
            <para>Calling this method will <b>safely</b> close and remove all
            appenders in all the loggers including root contained in the
            default repository.</para>

            <para>Some appenders need to be closed before the application exists.
            Otherwise, pending logging events might be lost.</para>

            <para>The <c>shutdown</c> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a logger
            and again to a nested appender.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">
            <summary>
            Shutdown the repository for the domain specified.
            </summary>
            <remarks>
            <para>Calling this method will <b>safely</b> close and remove all
            appenders in all the loggers including root contained in the
            repository for the <paramref name="domain"/> specified.</para>

            <para>Some appenders need to be closed before the application exists.
            Otherwise, pending logging events might be lost.</para>

            <para>The <c>shutdown</c> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a logger
            and again to a nested appender.</para>
            </remarks>
            <param name="domain">the domain to shutdown</param>
        </member>
        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">
            <summary>
            Shutdown the repository for the domain specified.
            </summary>
            <remarks>
            <para>Calling this method will <b>safely</b> close and remove all
            appenders in all the loggers including root contained in the
            repository for the domain. The domain is looked up using
            the <paramref name="assembly"/> specified.</para>

            <para>Some appenders need to be closed before the application exists.
            Otherwise, pending logging events might be lost.</para>

            <para>The <c>shutdown</c> method is careful to close nested
            appenders before closing regular appenders. This is allows
            configurations where a regular appender is attached to a logger
            and again to a nested appender.</para>
            </remarks>
            <param name="assembly">the assembly to use to lookup the domain</param>
        </member>
        <member name="M:log4net.LogManager.ResetConfiguration">
            <summary>
            Reset all values contained in this repositry instance to their defaults.
            </summary>
            <remarks>
            <para>Reset all values contained in the repositry instance to their
            defaults.  This removes all appenders from all loggers, sets
            the level of all non-root loggers to <c>null</c>,
            sets their additivity flag to <c>true</c> and sets the level
            of the root logger to <see cref="F:log4net.spi.Level.DEBUG"/>. Moreover,
            message disabling is set its default "off" value.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">
            <summary>
            Reset all values contained in this repositry instance to their defaults.
            </summary>
            <remarks>
            <para>Reset all values contained in the repositry instance to their
            defaults.  This removes all appenders from all loggers, sets
            the level of all non-root loggers to <c>null</c>,
            sets their additivity flag to <c>true</c> and sets the level
            of the root logger to <see cref="F:log4net.spi.Level.DEBUG"/>. Moreover,
            message disabling is set its default "off" value.</para>
            </remarks>
            <param name="domain">the domain to lookup in</param>
        </member>
        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">
            <summary>
            Reset all values contained in this repositry instance to their defaults.
            </summary>
            <remarks>
            <para>Reset all values contained in the repositry instance to their
            defaults.  This removes all appenders from all loggers, sets
            the level of all non-root loggers to <c>null</c>,
            sets their additivity flag to <c>true</c> and sets the level
            of the root logger to <see cref="F:log4net.spi.Level.DEBUG"/>. Moreover,
            message disabling is set its default "off" value.</para>
            </remarks>
            <param name="assembly">the assembly to use to lookup the domain</param>
        </member>
        <member name="M:log4net.LogManager.CreateDomain(System.Type)">
            <summary>
            Create a domain with the specifed repository type
            </summary>
            <param name="repositoryType">a <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
            and has a no arg constructor. An isnstance of this type will be created to act
            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain specified.</param>
            <returns>the <see cref="T:log4net.Repository.ILoggerRepository"/> created for the domain</returns>
            <remarks>
            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
            specified such that a call to <see cref="M:log4net.LogManager.GetLoggerRepository"/> will return
            the same repository instance.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.CreateDomain(System.String)">
            <summary>
            Create a domain with the specifed name
            </summary>
            <param name="domain">the name of the domain, this must be unique amongst domain</param>
            <returns>the <see cref="T:log4net.Repository.ILoggerRepository"/> created for the domain</returns>
            <remarks>
            <para>Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a
            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.</para>

            <para>The <paramref name="domain"/> name must be unique. Domains cannot be redefined.
            An <see cref="T:System.Exception"/> will be thrown if the domain already exists.</para>
            </remarks>
            <exception cref="T:log4net.spi.LogException">The specified domain already exists</exception>
        </member>
        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">
            <summary>
            Create a domain with the specifed name and repository type
            </summary>
            <param name="domain">the name of the domain, this must be unique to the domain</param>
            <param name="repositoryType">a <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
            and has a no arg constructor. An isnstance of this type will be created to act
            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain specified.</param>
            <returns>the <see cref="T:log4net.Repository.ILoggerRepository"/> created for the domain</returns>
            <remarks>
            <para>The <paramref name="domain"/> name must be unique. Domains cannot be redefined.
            An Exception will be thrown if the domain already exists.</para>
            </remarks>
            <exception cref="T:log4net.spi.LogException">The specified domain already exists</exception>
        </member>
        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">
            <summary>
            Create a domain for the specifed assembly and repository type
            </summary>
            <param name="assembly">the assembly to use to get the name of the domain</param>
            <param name="repositoryType">a <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>
            and has a no arg constructor. An isnstance of this type will be created to act
            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the domain specified.</param>
            <returns>the <see cref="T:log4net.Repository.ILoggerRepository"/> created for the domain</returns>
            <remarks>
            <para>The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain
            specified such that a call to <see cref="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)"/> with the
            same assembly specified will return the same repository instance.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.GetAllRepositories">
            <summary>
            Get the list of currently defined repositories
            </summary>
            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>
            <remarks>
            <para>Get the list of currently defined repositories</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.OnDomainUnload(System.Object,System.EventArgs)">
            <summary>
            Called when the <see cref="F:System.AppDomain.DomainUnload"/> event fires
            </summary>
            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
            <param name="e">null</param>
            <remarks>
            <para>Called when the <see cref="F:System.AppDomain.DomainUnload"/> event fires.</para>

            <para>When the event is triggered the log4net system is <see cref="M:log4net.LogManager.Shutdown"/>.</para>
            </remarks>
        </member>
        <member name="M:log4net.LogManager.OnProcessExit(System.Object,System.EventArgs)">
            <summary>
            Called when the <see cref="F:System.AppDomain.ProcessExit"/> event fires
            </summary>
            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>
            <param name="e">null</param>
            <remarks>
            <para>Called when the <see cref="F:System.AppDomain.ProcessExit"/> event fires.</para>

            <para>When the event is triggered the log4net system is <see cref="M:log4net.LogManager.Shutdown"/>.</para>
            </remarks>
        </member>
        <member name="P:log4net.LogManager.RepositorySelector">
            <summary>
            The repository selector used by the LogManager
            </summary>
            <value>
            The repository selector used by the LogManager
            </value>
            <remarks>
            <para>The repository selector (<see cref="T:log4net.spi.IRepositorySelector"/>)
            is used by the <see cref="T:log4net.LogManager"/> to create and
            select repositories (<see cref="T:log4net.Repository.ILoggerRepository"/>).</para>

            <para>The caller to <see cref="T:log4net.LogManager"/> supplies
            either a string name or an assembly (if not supplied the
            assembly is infered using <see cref="M:System.Reflection.Assembly.GetCallingAssembly"/>).
            This context is used by the selector to lookup a
            specific repository.</para>

            <para>The default repository selector is <see cref="T:log4net.spi.DefaultRepositorySelector"/>.</para>
            </remarks>
        </member>
        <member name="T:log4net.MDC">
            <summary>
            Implementation of Mapped Diagnostic Contexts.
            </summary>
            <remarks>
            <para>The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is
            based on a map instead of a stack. It provides <i>mapped
            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or
            MDC in short, is an instrument for distinguishing interleaved log
            output from different sources. Log output is typically interleaved
            when a server handles multiple clients near-simultaneously.</para>
            <para>The MDC is managed on a per thread basis</para>
            </remarks>
        </member>
        <member name="F:log4net.MDC.s_slot">
            <summary>
            The thread local data slot to use for context information
            </summary>
        </member>
        <member name="M:log4net.MDC.#ctor">
            <summary>
            Private constructor
            </summary>
        </member>
        <member name="M:log4net.MDC.Get(System.String)">
            <summary>
            Get the context identified by the <paramref name='key'/> parameter
            </summary>
            <remarks>
            Get the context identified by the <paramref name='key'/> parameter.
            If the <paramref name='key'/> parameter does not look up to a
            previously defined context then <c>null</c> will be retutrned.
            </remarks>
            <param name="key">the key to lookup in the MDC</param>
            <returns>the string value held for the key, or null</returns>
        </member>
        <member name="M:log4net.MDC.Set(System.String,System.String)">
            <summary>
            Put a context value (the <paramref name='val'/> parameter) as identified
            with the <paramref name='key'/> parameter into the current thread's
            context map.
            </summary>
            <remarks>
            If a value is already defined for the <paramref name='key'/>
            specified then the value will be replaced.
            If the <paramref name='val'/> is specified as <c>null</c> then
            the key value mapping will be removed.
            </remarks>
            <param name="key">the key to store the value under</param>
            <param name="value">the value to store</param>
        </member>
        <member name="M:log4net.MDC.Remove(System.String)">
            <summary>
            Removes the key value mapping for the key specified.
            </summary>
            <param name="key">the key to remove</param>
            <remarks>
            Removes the <paramref name="key"/> value mapping for the key specified.
            </remarks>
        </member>
        <member name="M:log4net.MDC.GetMap">
            <summary>
            Get the map on this thread
            </summary>
            <returns>the map</returns>
        </member>
        <member name="T:log4net.NDC">
            <summary>
            Implementation of Nested Diagnostic Contexts.
            </summary>
            <remarks>
            <para>A Nested Diagnostic Context, or NDC in short, is an instrument
            to distinguish interleaved log output from different sources. Log
            output is typically interleaved when a server handles multiple
            clients near-simultaneously.</para>
            <para>Interleaved log output can still be meaningful if each log entry
            from different contexts had a distinctive stamp. This is where NDCs
            come into play.</para>
            <para>Note that NDCs are managed on a per thread basis. The NDC class
            is made up of static methods that operate on the context of the
            calling thread.</para>
            </remarks>
            <example>How to push a message into the context
            <code>
            using(NDC.Push("my context message"))
            {
                ... all log calls will have 'my context message' included ...

            } // at the end of the using block the message is automatically removed
            </code>
            </example>
        </member>
        <member name="F:log4net.NDC.s_slot">
            <summary>
            The thread local data slot to use for context information
            </summary>
        </member>
        <member name="M:log4net.NDC.#ctor">
            <summary>
            Private constructor
            </summary>
        </member>
        <member name="M:log4net.NDC.Clear">
            <summary>
            Clears all the contextual information held on the
            current thread.
            </summary>
            <remarks>
            Clears all the contextual information held on the
            current thread. After calling this method the
            <see cref="P:log4net.NDC.Depth"/> will be <c>0</c>.
            </remarks>
        </member>
        <member name="M:log4net.NDC.CloneStack">
            <summary>
            Creates a clone of the stack of context information.
            </summary>
            <remarks>
            Creates a clone of the stack of context information. This
            can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> method to allow
            child threads to inherit the context of their parent thread.
            </remarks>
            <returns>a clone of the context info for this thread</returns>
        </member>
        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">
            <summary>
            Inherit the contextual information from another thread.
            </summary>
            <remarks>
            This thread will use the context information from the stack
            supplied. This can be used to initialise child threads with
            the same contextual information as their parent theads. These
            contexts will <b>NOT</b> be shared. Any further contexts that
            are pushed onto the stack will not be visisble to the other.
            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to
            this method.
            </remarks>
            <param name="stack">The context stack to inherit</param>
        </member>
        <member name="M:log4net.NDC.Get">
            <summary>
            Get the current context information.
            </summary>
            <remarks>
            Get the current context information. That is all the messages that
            have been pushed on to the context stack.
            </remarks>
            <returns>The current context information</returns>
        </member>
        <member name="M:log4net.NDC.Pop">
            <summary>
            Remove the top context from the stack
            </summary>
            <remarks>
            Remove the top context from the stack, and return
            it to the caller. If the stack is empty then an
            empty string (not null) is returned.
            </remarks>
            <returns>the message in the context that was removed from the top of the stack</returns>
        </member>
        <member name="M:log4net.NDC.Peek">
            <summary>
            Peek at the message on the top of the context stack
            </summary>
            <returns>The message on the top of the stack</returns>
        </member>
        <member name="M:log4net.NDC.Push(System.String)">
            <summary>
            Push a new context message
            </summary>
            <param name="message">The new context message</param>
            <returns>An <see cref="T:System.IDisposable"/> is returned that
            can be used to clean up the context stack</returns>
            <remarks>
            Push a new context onto the context stack. An <see cref="T:System.IDisposable"/>
            is returned that can be used to clean up the context stack. This
            can be easily combined with the <c>using</c> keyword to scope the
            conext.
            </remarks>
            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.
            <code>
            using(log4net.NDC.Push("NDC_Message"))
            {
                log.Warn("This should have an NDC message");
            }
            </code>
            </example>
        </member>
        <member name="M:log4net.NDC.Remove">
            <summary>
            Remove the context information for this thread. It is
            not required to call this method.
            </summary>
            <remarks>
            This method is not implemented.
            </remarks>
        </member>
        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">
            <summary>
            Forces the stack depth to be at most <paramref name="maxDepth"/>.
            </summary>
            <remarks>
            Forces the stack depth to be at most <paramref name="maxDepth"/>.
            This may truncate the head of the stack. This only affects the
            stack in the current thread. Also it does not prevent it from
            growing, it only sets the maximum depth at the time of the
            call. This can be used to return to a known context depth.
            </remarks>
            <param name="maxDepth">The maximum depth of the stack</param>
        </member>
        <member name="M:log4net.NDC.GetStack">
            <summary>
            Get the stack of context objects on this thread
            </summary>
            <returns>the stack of context objects</returns>
        </member>
        <member name="P:log4net.NDC.Depth">
            <summary>
            Get the current context depth
            </summary>
            <value>the current context depth</value>
            <remarks>
            Get the current context depth
            </remarks>
        </member>
        <member name="T:log4net.NDC.DiagnosticContext">
            <summary>
            Inner class used to represent a single context in the stack
            </summary>
        </member>
        <member name="M:log4net.NDC.DiagnosticContext.#ctor(System.String,log4net.NDC.DiagnosticContext)">
            <summary>
            Construct a new context
            </summary>
            <param name="message">The nessage for this context</param>
            <param name="parent">The parent context in the chain</param>
        </member>
        <member name="P:log4net.NDC.DiagnosticContext.Message">
            <summary>
            Get the message
            </summary>
        </member>
        <member name="P:log4net.NDC.DiagnosticContext.FullMessage">
            <summary>
            Get the full text of the context down to the root level
            </summary>
        </member>
        <member name="T:log4net.NDC.NDCAutoDisposeFrame">
            <summary>
            Inner class that is returned from <see cref="M:log4net.NDC.Push(System.String)"/>
            </summary>
            <remarks>
            Inner class that is returned from <see cref="M:log4net.NDC.Push(System.String)"/>.
            This class is disposable and when it is disoposed it automatically
            returns the NDC to the corect depth.
            </remarks>
        </member>
        <member name="F:log4net.NDC.NDCAutoDisposeFrame.m_frameStack">
            <summary>
            The NDC internal stack
            </summary>
        </member>
        <member name="F:log4net.NDC.NDCAutoDisposeFrame.m_frameDepth">
            <summary>
            The depth to rethr the stack to when this instance is disposed
            </summary>
        </member>
        <member name="M:log4net.NDC.NDCAutoDisposeFrame.#ctor(System.Collections.Stack,System.Int32)">
            <summary>
            Construct a new instance with the stack and return depth specified
            </summary>
            <param name="frameStack">the internal stack used by the NDC</param>
            <param name="frameDepth">the depth to return the stack to when this object is disposed</param>
        </member>
        <member name="M:log4net.NDC.NDCAutoDisposeFrame.Dispose">
            <summary>
            Return the NDC stack to the correct depth
            </summary>
        </member>
        <member name="T:log4net.Priority">
            <summary>
            <b>Deprecated.</b> Replaced by the <see cref="T:log4net.spi.Level"/> class.
            </summary>
            <remarks>
            <para>Defines the minimum set of priorities recognized by the system,
            that is FATAL, ERROR, WARN, INFO and DEBUG.</para>

            <para><b>The Priority class has been replaced by the Level class</b></para>
            </remarks>
        </member>
        <member name="F:log4net.Priority.FATAL">
            <summary>
            The <c>FATAL</c> priority designates very severe error events that will presumably lead the application to abort.
            </summary>
        </member>
        <member name="F:log4net.Priority.ERROR">
            <summary>
            The <c>ERROR</c> priority designates error events that might still allow the application to continue running.
            </summary>
        </member>
        <member name="F:log4net.Priority.WARN">
            <summary>
            The <c>WARN</c> priority designates potentially harmful situations.
            </summary>
        </member>
        <member name="F:log4net.Priority.INFO">
            <summary>
            The <c>INFO</c> priority designates informational messages that highlight the progress of the application at coarse-grained level.
            </summary>
        </member>
        <member name="F:log4net.Priority.DEBUG">
            <summary>
            The <c>DEBUG</c> priority designates fine-grained informational events that are most useful to debug an application.
            </summary>
        </member>
        <member name="F:log4net.Priority.OFF">
            <summary>
            The <c>OFF</c> priority designates a lower level priority than all the rest.
            </summary>
        </member>
        <member name="M:log4net.Priority.#ctor(log4net.spi.Level)">
            <summary>
            Instantiate a priority object.
            </summary>
            <param name="level"></param>
        </member>
        <member name="M:log4net.Priority.ToString">
            <summary>
            Returns the string representation of this priority.
            </summary>
            <returns></returns>
        </member>
        <member name="M:log4net.Priority.Equals(System.Object)">
            <summary>
            Override Equals to compare the levels of
            Priority objects. Defers to base class if
            the target object is not a Priority.
            </summary>
            <param name="o">The object to compare against</param>
            <returns>true if the objects are equal</returns>
        </member>
        <member name="M:log4net.Priority.GetHashCode">
            <summary>
            Returns a hash code that is sutable for use in a hashtree etc
            </summary>
            <returns>the hash of this object</returns>
        </member>
        <member name="M:log4net.Priority.op_GreaterThan(log4net.Priority,log4net.Priority)">
            <summary>
            Operator greater than that compares Priorities
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is greater than the right hand side</returns>
        </member>
        <member name="M:log4net.Priority.op_LessThan(log4net.Priority,log4net.Priority)">
            <summary>
            Operator less than that compares Priorities
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is less than the right hand side</returns>
        </member>
        <member name="M:log4net.Priority.op_GreaterThanOrEqual(log4net.Priority,log4net.Priority)">
            <summary>
            Operator greater than or equal that compares Priorities
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is greater than or equal to the right hand side</returns>
        </member>
        <member name="M:log4net.Priority.op_LessThanOrEqual(log4net.Priority,log4net.Priority)">
            <summary>
            Operator less than or equal that compares Priorities
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is less than or equal to the right hand side</returns>
        </member>
        <member name="M:log4net.Priority.op_Equality(log4net.Priority,log4net.Priority)">
            <summary>
            Operator equals that compares Priorities
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is equal to the right hand side</returns>
        </member>
        <member name="M:log4net.Priority.op_Inequality(log4net.Priority,log4net.Priority)">
            <summary>
            Operator not equals that compares Priorities
            </summary>
            <param name="l">left hand side</param>
            <param name="r">right hand side</param>
            <returns>true if left hand side is not equal to the right hand side</returns>
        </member>
        <member name="M:log4net.Priority.op_Implicit(log4net.Priority)~log4net.spi.Level">
            <summary>
            Implicit conversion to Level class
            </summary>
            <param name="p">the Priority object to convert to a Level object</param>
            <returns>the Level representation of the Priority</returns>
        </member>
        <member name="M:log4net.Priority.Parse(System.String)">
            <summary>
            Convert the string passed as argument to a priority. If the
            conversion fails, then this method returns <see cref="F:log4net.Priority.DEBUG"/>.
            </summary>
            <param name="sArg">The string to parse into a Priority</param>
            <returns>The Priority represented by the string argument</returns>
        </member>
        <member name="M:log4net.Priority.Parse(System.Int32)">
            <summary>
            Convert an integer passed as argument to a priority. If the
            conversion fails, then this method returns <see cref="F:log4net.Priority.DEBUG"/>.
            </summary>
            <param name="val">The int to convert to a Priority</param>
            <returns>The Priority represented by the argument</returns>
        </member>
        <member name="M:log4net.Priority.Parse(System.Int32,log4net.Priority)">
            <summary>
            Convert an integer passed as argument to a priority. If the
            conversion fails, then this method returns the specified default.
            </summary>
            <param name="val">The value to convert to a Prority</param>
            <param name="defaultPriority">The default Priority value to use</param>
            <returns>The Priority represented by the Argument</returns>
        </member>
        <member name="M:log4net.Priority.Parse(System.String,log4net.Priority)">
            <summary>
            Convert the string passed as argument to a priority. If the
            conversion fails, then this method returns the value of
            <c>defaultPriority</c>.
            </summary>
            <param name="sArg">The string to parse</param>
            <param name="defaultPriority">the default Priority to use</param>
            <returns>The Priority represented by the argument</returns>
        </member>
    </members>
</doc>