<?xml version="1.0"?>

<doc>

    <assembly>

        <name>log4net</name>

    </assembly>

    <members>

        <member name="T:log4net.Appender.AdoNetAppender">

            <summary>

            Appender that logs to a database.

            </summary>

            <remarks>

            <para>

            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging 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 connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>

            property. For more information on database connection strings for

            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.

            </para>

            <para>

            Records are written into the database either using a prepared

            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property

            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement

            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored

            procedure.

            </para>

            <para>

            The prepared statement text or the name of the stored procedure

            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.

            </para>

            <para>

            The prepared statement or stored procedure can take a number

            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>

            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the

            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>

            type may be subclassed if required to provide database specific

            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies

            the parameter name, database type, size, and how the value should

            be generated using a <see cref="T:log4net.Layout.ILayout"/>.

            </para>

            </remarks>

            <example>

            An example of a SQL Server table that could be logged to:

            <code lang="SQL">

            CREATE TABLE [dbo].[Log] ( 

              [ID] [int] IDENTITY (1, 1) NOT NULL ,

              [Date] [datetime] NOT NULL ,

              [Thread] [varchar] (255) NOT NULL ,

              [Level] [varchar] (20) NOT NULL ,

              [Logger] [varchar] (255) NOT NULL ,

              [Message] [varchar] (4000) NOT NULL 

            ) ON [PRIMARY]

            </code>

            </example>

            <example>

            An example configuration to log to the above table:

            <code lang="XML" escaped="true">

            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">

              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>

              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>

              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>

              <parameter>

                <parameterName value="@log_date"/>

                <dbType value="DateTime"/>

                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>

              </parameter>

              <parameter>

                <parameterName value="@thread"/>

                <dbType value="String"/>

                <size value="255"/>

                <layout type="log4net.Layout.PatternLayout" value="%thread"/>

              </parameter>

              <parameter>

                <parameterName value="@log_level"/>

                <dbType value="String"/>

                <size value="50"/>

                <layout type="log4net.Layout.PatternLayout" value="%level"/>

              </parameter>

              <parameter>

                <parameterName value="@logger"/>

                <dbType value="String"/>

                <size value="255"/>

                <layout type="log4net.Layout.PatternLayout" value="%logger"/>

              </parameter>

              <parameter>

                <parameterName value="@message"/>

                <dbType value="String"/>

                <size value="4000"/>

                <layout type="log4net.Layout.PatternLayout" value="%message"/>

              </parameter>

            </appender>

            </code>

            </example>

            <author>Julian Biddle</author>

            <author>Nicko Cadell</author>

            <author>Gert Driesen</author>

            <author>Lance Nehring</author>

        </member>

        <member name="T:log4net.Appender.BufferingAppenderSkeleton">

            <summary>

            Abstract base class 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.AdoNetAppender"/> 

            buffers events and then submits the entire contents of the buffer to 

            the underlying database in one go.

            </para>

            <para>

            Subclasses should override the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.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.Core.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 immediately 

            (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>). Otherwise the event 

            is stored in the buffer. For example, an evaluator can be used to 

            deliver the events immediately 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.Core.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 useful behavior 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 up to

            the ERROR event.

            </para>

            </remarks>

            <author>Nicko Cadell</author>

            <author>Gert Driesen</author>

        </member>

        <member name="T:log4net.Appender.AppenderSkeleton">

            <summary>

            Abstract base class 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>

            <para>

            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore

            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method

            be called after the appenders properties have been configured.

            </para>

            </remarks>

            <author>Nicko Cadell</author>

            <author>Gert Driesen</author>

        </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>

            <para>

            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore

            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method

            be called after the appenders properties have been configured.

            </para>

            </remarks>

            <author>Nicko Cadell</author>

            <author>Gert Driesen</author>

        </member>

        <member name="M:log4net.Appender.IAppender.Close">

            <summary>

            Closes the appender and releases resources.

            </summary>

            <remarks>

            <para>

            Releases 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.Core.LoggingEvent)">

            <summary>

            Log the logging event in Appender specific way.

            </summary>

            <param name="loggingEvent">The event to log</param>

            <remarks>

            <para>

            This method is called to log a message into this appender.

            </para>

            </remarks>

        </member>

        <member name="P:log4net.Appender.IAppender.Name">

            <summary>

            Gets or sets the name of this appender.

            </summary>

            <value>The name of the appender.</value>

            <remarks>

            <para>The name uniquely identifies the appender.</para>

            </remarks>

        </member>

        <member name="T:log4net.Appender.IBulkAppender">

            <summary>

            Interface for appenders that support bulk logging.

            </summary>

            <remarks>

            <para>

            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to

            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders

            should only implement this interface if they can bulk log efficiently.

            </para>

            </remarks>

            <author>Nicko Cadell</author>

        </member>

        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">

            <summary>

            Log the array of logging events in Appender specific way.

            </summary>

            <param name="loggingEvents">The events to log</param>

            <remarks>

            <para>

            This method is called to log an array of events into this appender.

            </para>

            </remarks>

        </member>

        <member name="T:log4net.Core.IOptionHandler">

            <summary>

            Interface used to delay activate a configured object.

            </summary>

            <remarks>

            <para>

            This allows an object to defer activation of its options until all

            options have been set. This is required for components which have

            related options that remain ambiguous until all are set.

            </para>

            <para>

            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 

            must be called by the container after its all the configured properties have been set 

            and before the component can be used.

            </para>

            </remarks>

            <author>Nicko Cadell</author>

        </member>

        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">

            <summary>

            Activate the options that were previously set with calls to properties.

            </summary>

            <remarks>

            <para>

            This allows an object to defer activation of its options until all

            options have been set. This is required for components which have

            related options that remain ambiguous until all are set.

            </para>

            <para>

            If a component implements this interface then this method must be called

            after its properties have been set before the component can be used.

            </para>

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">

            <summary>

            Initial buffer size

            </summary>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">

            <summary>

            Maximum buffer size before it is recycled

            </summary>

        </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.Finalize">

            <summary>

            Finalizes this appender by calling the implementation's 

            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.

            </summary>

            <remarks>

            <para>

            If this appender has not been closed then the <c>Finalize</c> method

            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">

            <summary>

            Initialize the appender based on the options set

            </summary>

            <remarks>

            <para>

            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object

            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 

            be called on this object after the configuration properties have

            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this

            object is in an undefined state and must not be used. 

            </para>

            <para>

            If any of the configuration properties are modified then 

            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.Close">

            <summary>

            Closes 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 overridden by subclasses. This method 

            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>

            method which must be overridden in the subclass.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">

            <summary>

            Performs threshold checks and invokes filters before 

            delegating actual logging to the subclasses specific 

            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.

            </summary>

            <param name="loggingEvent">The event to log.</param>

            <remarks>

            <para>

            This method cannot be overridden by derived classes. A

            derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method

            which is called by this method.

            </para>

            <para>

            The implementation of this method is as follows:

            </para>

            <para>

            <list type="bullet">

            	<item>

            		<description>

            		Checks 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>

            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 

            		<paramref name="loggingEvent"/>.

            		</description>

            	</item>

            	<item>

            		<description>

            		Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that 

            		it returns <c>true</c>.</description>

            	</item>

            </list>

            </para>

            <para>

            If all of the above steps succeed then the <paramref name="loggingEvent"/>

            will be passed to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">

            <summary>

            Performs threshold checks and invokes filters before 

            delegating actual logging to the subclasses specific 

            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.

            </summary>

            <param name="loggingEvents">The array of events to log.</param>

            <remarks>

            <para>

            This method cannot be overridden by derived classes. A

            derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method

            which is called by this method.

            </para>

            <para>

            The implementation of this method is as follows:

            </para>

            <para>

            <list type="bullet">

            	<item>

            		<description>

            		Checks 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>

            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 

            		<paramref name="loggingEvent"/>.

            		</description>

            	</item>

            	<item>

            		<description>

            		Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that 

            		it returns <c>true</c>.</description>

            	</item>

            </list>

            </para>

            <para>

            If all of the above steps succeed then the <paramref name="loggingEvents"/>

            will be passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">

            <summary>

            Test if the logging event should we output by this appender

            </summary>

            <param name="loggingEvent">the event to test</param>

            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>

            <remarks>

            <para>

            This method checks the logging event against the threshold level set

            on this appender and also against the filters specified on this

            appender.

            </para>

            <para>

            The implementation of this method is as follows:

            </para>

            <para>

            <list type="bullet">

            	<item>

            		<description>

            		Checks 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>

            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 

            		<paramref name="loggingEvent"/>.

            		</description>

            	</item>

            </list>

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">

            <summary>

            Adds a filter to the end of the filter chain.

            </summary>

            <param name="filter">the filter to add to this appender</param>

            <remarks>

            <para>

            The Filters are organized in a linked list.

            </para>

            <para>

            Setting this property causes the new filter to be pushed onto the 

            back of the filter chain.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">

            <summary>

            Clears the filter list for this appender.

            </summary>

            <remarks>

            <para>

            Clears the filter list for this appender.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">

            <summary>

            Checks if the message level is below this appender's threshold.

            </summary>

            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>

            <remarks>

            <para>

            If there is no threshold set, then the return value is always <c>true</c>.

            </para>

            </remarks>

            <returns>

            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 

            requirements of this appender.

            </returns>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">

            <summary>

            Is called when the appender is closed. Derived classes should override 

            this method if resources need to be released.

            </summary>

            <remarks>

            <para>

            Releases 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.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">

            <summary>

            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 

            to perform actual logging.

            </summary>

            <param name="loggingEvent">The event to append.</param>

            <remarks>

            <para>

            A subclass must implement this method to perform

            logging of the <paramref name="loggingEvent"/>.

            </para>

            <para>This method will be called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.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.Append(log4net.Core.LoggingEvent[])">

            <summary>

            Append a bulk array of logging events.

            </summary>

            <param name="loggingEvents">the array of logging events</param>

            <remarks>

            <para>

            This base class implementation calls the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>

            method for each element in the bulk array.

            </para>

            <para>

            A sub class that can better process a bulk array of events should

            override this method in addition to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">

            <summary>

            Called before <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> as a precondition.

            </summary>

            <remarks>

            <para>

            This method is called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>

            before the call to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.

            </para>

            <para>

            This method can be overridden in a subclass to extend the checks 

            made before the event is passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.

            </para>

            <para>

            A subclass should ensure that they delegate this call to

            this base class if it is overridden.

            </para>

            </remarks>

            <returns><c>true</c> if the call to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> should proceed.</returns>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">

            <summary>

            Renders the <see cref="T:log4net.Core.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.Core.LoggingEvent"/> to 

            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>

            set 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>

            <para>

            Where possible use the alternative version of this method

            <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)"/>.

            That method streams the rendering onto an existing Writer

            which can give better performance if the caller already has

            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">

            <summary>

            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.

            </summary>

            <param name="loggingEvent">The event to render.</param>

            <param name="writer">The TextWriter to write the formatted event to</param>

            <remarks>

            <para>

            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 

            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>

            set 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>

            <para>

            Use this method in preference to <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/>

            where possible. If, however, the caller needs to render the event

            to a string then <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/> does

            provide an efficient mechanism for doing so.

            </para>

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">

            <summary>

            The layout of this appender.

            </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>

            The level threshold of this appender.

            </summary>

            <remarks>

            <para>

            There is no level threshold filtering by default.

            </para>

            <para>

            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.

            </para>

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">

            <summary>

            It is assumed and enforced that errorHandler is never null.

            </summary>

            <remarks>

            <para>

            It is assumed and enforced that errorHandler is never null.

            </para>

            <para>

            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.

            </para>

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">

            <summary>

            The first filter in the filter chain.

            </summary>

            <remarks>

            <para>

            Set to <c>null</c> initially.

            </para>

            <para>

            See <see cref="T:log4net.Filter.IFilter"/> for more information.

            </para>

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">

            <summary>

            The last filter in the filter chain.

            </summary>

            <remarks>

            See <see cref="T:log4net.Filter.IFilter"/> for more information.

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">

            <summary>

            Flag indicating if this appender is closed.

            </summary>

            <remarks>

            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.

            </remarks>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">

            <summary>

            The guard prevents an appender from repeatedly calling its own DoAppend method

            </summary>

        </member>

        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">

            <summary>

            StringWriter used to render events

            </summary>

        </member>

        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">

            <summary>

            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.

            </summary>

            <value>

            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 

            </value>

            <remarks>

            <para>

            All log events with lower level than the threshold level are ignored 

            by the appender.

            </para>

            <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>

            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.

            </summary>

            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>

            <remarks>

            <para>

            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 

            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 

            </para>

            </remarks>

        </member>

        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">

            <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>

            </remarks>

        </member>

        <member name="P:log4net.Appender.AppenderSkeleton.Layout">

            <summary>

            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.

            </summary>

            <value>The layout of the appender.</value>

            <remarks>

            <para>

            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.

            </para>

            </remarks>

            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>

        </member>

        <member name="P:log4net.Appender.AppenderSkeleton.Name">

            <summary>

            Gets or sets the name of this appender.

            </summary>

            <value>The name of the appender.</value>

            <remarks>

            <para>

            The name uniquely identifies the appender.

            </para>

            </remarks>

        </member>

        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">

            <summary>

            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.

            </summary>

            <remarks>

            <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 default implementation always returns <c>true</c>.

            </para>

            </remarks>

            <returns>

            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.

            </returns>

        </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="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">

            <summary>

            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.

            </summary>

            <remarks>

            <para>

            Protected default constructor to allow subclassing.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">

            <summary>

            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.

            </summary>

            <param name="eventMustBeFixed">the events passed through this appender must be

            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>

            <remarks>

            <para>

            Protected constructor to allow subclassing.

            </para>

            <para>

            The <paramref name="eventMustBeFixed"/> should be set if the subclass

            expects the events delivered to be fixed even if the 

            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">

            <summary>

            Flush the currently buffered events

            </summary>

            <remarks>

            <para>

            Flushes any events that have been buffered.

            </para>

            <para>

            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents

            of the buffer will NOT be flushed to the appender.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">

            <summary>

            Flush the currently buffered events

            </summary>

            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>

            <remarks>

            <para>

            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is

            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.

            </para>

            <para>

            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents

            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.

            In this case the contents of the buffer will be tested against the 

            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered

            events will be discarded.

            </para>

            <para>

            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always

            be emptied by calling this method.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">

            <summary>

            Initialize the appender based on the options set

            </summary>

            <remarks>

            <para>

            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object

            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 

            be called on this object after the configuration properties have

            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this

            object is in an undefined state and must not be used. 

            </para>

            <para>

            If any of the configuration properties are modified then 

            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.

            </para>

            </remarks>

        </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.Core.LoggingEvent)">

            <summary>

            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.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.Core.LoggingEvent[])"/> 

            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.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)"/>) 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.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">

            <summary>

            Sends the contents of the buffer.

            </summary>

            <param name="firstLoggingEvent">The first logging event.</param>

            <param name="buffer">The buffer containing the events that need to be send.</param>

            <remarks>

            <para>

            The subclass must override <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>.

            </para>

            </remarks>

        </member>

        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">

            <summary>

            Sends the events.

            </summary>

            <param name="events">The events that need to be send.</param>

            <remarks>

            <para>

            The subclass must override this method to process the buffered events.

            </para>

            </remarks>

        </member>

        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">

            <summary>

            The size of the cyclic buffer used to hold the logging events.

            </summary>

            <remarks>

            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.

            </remarks>

        </member>

        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">

            <summary>

            The cyclic buffer used to store the logging events.

            </summary>

        </member>

        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">

            <summary>

            The triggering event evaluator that causes the buffer to be sent immediately.

            </summary>

            <remarks>

            The object that is used to determine if an event causes the entire

            buffer to be sent immediately. 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>

            Indicates if the appender should overwrite events in the cyclic buffer 

            when it becomes full, or if the buffer should be flushed when the 

            buffer is full.

            </summary>

            <remarks>

            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="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">

            <summary>

            The triggering event evaluator filters discarded events.

            </summary>

            <remarks>

            The object that is used to determine if an event that is discarded should

            really be discarded or if it should be sent to the appenders. 

            This field can be <c>null</c>, which indicates that all discarded events will

            be discarded. 

            </remarks>

        </member>

        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">

            <summary>

            Value indicating which fields in the event should be fixed

            </summary>

            <remarks>

            By default all fields are fixed

            </remarks>

        </member>

        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">

            <summary>

            The events delivered to the subclass must be fixed.

            </summary>

        </member>

        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">

            <summary>

            Gets or sets a value that indicates whether the appender is lossy.

            </summary>

            <value>

            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.

            </value>

            <remarks>

            <para>

            This appender uses a buffer to store logging events before 

            delivering them. A triggering event causes the whole buffer

            to be send to the remote sink. If the buffer overruns before

            a triggering event then logging events could be lost. Set

            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 

            from being lost.

            </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>…