Changeset 1527 for trunk/AppReferences


Ignore:
Timestamp:
May 29, 2010, 3:08:17 PM (12 years ago)
Author:
Paul Lelgemann
Message:

o Updated Peer@Play-DLLs to support IrcBootstrapperV2
o CrypP2P: Switched to built-in settings
+ P2PEditor: Moved settings to settings pane and wired them to the new CrypP2P settings style
o P2PEditor: Play button connects P2P network

Location:
trunk/AppReferences
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/AppReferences/x64/log4net.xml

    r1478 r1527  
    55    </assembly>
    66    <members>
    7         <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">
    8             <summary>
    9             Attribute used to associate a type converter
    10             </summary>
    11             <remarks>
    12             <para>
    13             Class and Interface level attribute that specifies a type converter
    14             to use with the associated type.
    15             </para>
    16             <para>
    17             To associate a type converter with a target type apply a
    18             <c>TypeConverterAttribute</c> to the target type. Specify the
    19             type of the type converter on the attribute.
     7        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
     8            <summary>
     9            Exception base type for conversion errors.
     10            </summary>
     11            <remarks>
     12            <para>
     13            This type extends <see cref="T:System.ApplicationException"/>. It
     14            does not add any new functionality but does differentiate the
     15            type of exception being thrown.
    2016            </para>
    2117            </remarks>
     
    2319            <author>Gert Driesen</author>
    2420        </member>
    25         <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">
    26             <summary>
    27             The string type name of the type converter
    28             </summary>
    29         </member>
    30         <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">
    31             <summary>
    32             Default constructor
    33             </summary>
    34             <remarks>
    35             <para>
    36             Default constructor
    37             </para>
    38             </remarks>
    39         </member>
    40         <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">
    41             <summary>
    42             Create a new type converter attribute for the specified type name
    43             </summary>
    44             <param name="typeName">The string type name of the type converter</param>
    45             <remarks>
    46             <para>
    47             The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
    48             or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
    49             </para>
    50             </remarks>
    51         </member>
    52         <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">
    53             <summary>
    54             Create a new type converter attribute for the specified type
    55             </summary>
    56             <param name="converterType">The type of the type converter</param>
    57             <remarks>
    58             <para>
    59             The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
    60             or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
    61             </para>
    62             </remarks>
    63         </member>
    64         <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">
    65             <summary>
    66             The string type name of the type converter
     21        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">
     22            <summary>
     23            Constructor
     24            </summary>
     25            <remarks>
     26            <para>
     27            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
     28            </para>
     29            </remarks>
     30        </member>
     31        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">
     32            <summary>
     33            Constructor
     34            </summary>
     35            <param name="message">A message to include with the exception.</param>
     36            <remarks>
     37            <para>
     38            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
     39            with the specified message.
     40            </para>
     41            </remarks>
     42        </member>
     43        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">
     44            <summary>
     45            Constructor
     46            </summary>
     47            <param name="message">A message to include with the exception.</param>
     48            <param name="innerException">A nested exception to include.</param>
     49            <remarks>
     50            <para>
     51            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
     52            with the specified message and inner exception.
     53            </para>
     54            </remarks>
     55        </member>
     56        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
     57            <summary>
     58            Serialization constructor
     59            </summary>
     60            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
     61            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
     62            <remarks>
     63            <para>
     64            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class
     65            with serialized data.
     66            </para>
     67            </remarks>
     68        </member>
     69        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">
     70            <summary>
     71            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
     72            </summary>
     73            <param name="destinationType">The conversion destination type.</param>
     74            <param name="sourceValue">The value to convert.</param>
     75            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
     76            <remarks>
     77            <para>
     78            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
     79            </para>
     80            </remarks>
     81        </member>
     82        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">
     83            <summary>
     84            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
     85            </summary>
     86            <param name="destinationType">The conversion destination type.</param>
     87            <param name="sourceValue">The value to convert.</param>
     88            <param name="innerException">A nested exception to include.</param>
     89            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>
     90            <remarks>
     91            <para>
     92            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.
     93            </para>
     94            </remarks>
     95        </member>
     96        <member name="T:log4net.Util.ThreadContextStacks">
     97            <summary>
     98            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
     99            </summary>
     100            <remarks>
     101            <para>
     102            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>
     103            </para>
     104            </remarks>
     105            <author>Nicko Cadell</author>
     106        </member>
     107        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">
     108            <summary>
     109            Internal constructor
     110            </summary>
     111            <remarks>
     112            <para>
     113            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.
     114            </para>
     115            </remarks>
     116        </member>
     117        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">
     118            <summary>
     119            Gets the named thread context stack
    67120            </summary>
    68121            <value>
    69             The string type name of the type converter
     122            The named stack
    70123            </value>
    71124            <remarks>
    72125            <para>
    73             The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
    74             or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.
    75             </para>
    76             </remarks>
    77         </member>
    78         <member name="T:log4net.Util.OnlyOnceErrorHandler">
    79             <summary>
    80             Implements log4net's default error handling policy which consists
    81             of emitting a message for the first error in an appender and
    82             ignoring all subsequent errors.
    83             </summary>
    84             <remarks>
    85             <para>
    86             The error message is printed on the standard error output stream.
    87             </para>
    88             <para>
    89             This policy aims at protecting an otherwise working application
    90             from being flooded with error messages when logging fails.
     126            Gets the named thread context stack
     127            </para>
     128            </remarks>
     129        </member>
     130        <member name="T:log4net.Util.TextWriterAdapter">
     131            <summary>
     132            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
     133            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
     134            </summary>
     135            <remarks>
     136            <para>
     137            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all
     138            messages to an instance of <see cref="T:System.IO.TextWriter"/>.
    91139            </para>
    92140            </remarks>
    93141            <author>Nicko Cadell</author>
    94             <author>Gert Driesen</author>
    95         </member>
    96         <member name="T:log4net.Core.IErrorHandler">
    97             <summary>
    98             Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.
    99             </summary>
    100             <remarks>
    101             <para>
    102             Error handling is a particularly tedious to get right because by
    103             definition errors are hard to predict and to reproduce.
    104             </para>
    105             </remarks>
    106             <author>Nicko Cadell</author>
    107             <author>Gert Driesen</author>
    108         </member>
    109         <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
    110             <summary>
    111             Handles the error and information about the error condition is passed as
    112             a parameter.
    113             </summary>
    114             <param name="message">The message associated with the error.</param>
    115             <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
    116             <param name="errorCode">The error code associated with the error.</param>
    117             <remarks>
    118             <para>
    119             Handles the error and information about the error condition is passed as
    120             a parameter.
    121             </para>
    122             </remarks>
    123         </member>
    124         <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">
    125             <summary>
    126             Prints the error message passed as a parameter.
    127             </summary>
    128             <param name="message">The message associated with the error.</param>
    129             <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>
    130             <remarks>
    131             <para>
    132             See <see cref="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)"/>.
    133             </para>
    134             </remarks>
    135         </member>
    136         <member name="M:log4net.Core.IErrorHandler.Error(System.String)">
    137             <summary>
    138             Prints the error message passed as a parameter.
    139             </summary>
    140             <param name="message">The message associated with the error.</param>
    141             <remarks>
    142             <para>
    143             See <see cref="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)"/>.
    144             </para>
    145             </remarks>
    146         </member>
    147         <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">
    148             <summary>
    149             Default Constructor
    150             </summary>
    151             <remarks>
    152             <para>
    153             Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.
    154             </para>
    155             </remarks>
    156         </member>
    157         <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">
    158             <summary>
    159             Constructor
    160             </summary>
    161             <param name="prefix">The prefix to use for each message.</param>
    162             <remarks>
    163             <para>
    164             Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class
    165             with the specified prefix.
    166             </para>
    167             </remarks>
    168         </member>
    169         <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">
    170             <summary>
    171             Log an Error
    172             </summary>
    173             <param name="message">The error message.</param>
    174             <param name="e">The exception.</param>
    175             <param name="errorCode">The internal error code.</param>
    176             <remarks>
    177             <para>
    178             Prints the message and the stack trace of the exception on the standard
    179             error output stream.
    180             </para>
    181             </remarks>
    182         </member>
    183         <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">
    184             <summary>
    185             Log an Error
    186             </summary>
    187             <param name="message">The error message.</param>
    188             <param name="e">The exception.</param>
    189             <remarks>
    190             <para>
    191             Prints the message and the stack trace of the exception on the standard
    192             error output stream.
    193             </para>
    194             </remarks>
    195         </member>
    196         <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">
    197             <summary>
    198             Log an error
    199             </summary>
    200             <param name="message">The error message.</param>
    201             <remarks>
    202             <para>
    203             Print a the error message passed as parameter on the standard
    204             error output stream.
    205             </para>
    206             </remarks>
    207         </member>
    208         <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">
    209             <summary>
    210             Flag to indicate if it is the first error
    211             </summary>
    212         </member>
    213         <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">
    214             <summary>
    215             String to prefix each message with
    216             </summary>
    217         </member>
    218         <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">
    219             <summary>
    220             Is error logging enabled
    221             </summary>
    222             <remarks>
    223             <para>
    224             Is error logging enabled. Logging is only enabled for the
    225             first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.
    226             </para>
    227             </remarks>
    228         </member>
    229         <member name="T:log4net.ObjectRenderer.RendererMap">
    230             <summary>
    231             Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.
    232             </summary>
    233             <remarks>
    234             <para>
    235             Maintains a mapping between types that require special
    236             rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that
    237             is used to render them.
    238             </para>
    239             <para>
    240             The <see cref="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)"/> method is used to render an
    241             <c>object</c> using the appropriate renderers defined in this map.
    242             </para>
    243             </remarks>
    244             <author>Nicko Cadell</author>
    245             <author>Gert Driesen</author>
    246         </member>
    247         <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">
    248             <summary>
    249             Default Constructor
    250             </summary>
    251             <remarks>
    252             <para>
    253             Default constructor.
    254             </para>
    255             </remarks>
    256         </member>
    257         <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">
    258             <summary>
    259             Render <paramref name="obj"/> using the appropriate renderer.
    260             </summary>
    261             <param name="obj">the object to render to a string</param>
    262             <returns>the object rendered as a string</returns>
    263             <remarks>
    264             <para>
    265             This is a convenience method used to render an object to a string.
    266             The alternative method <see cref="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)"/>
    267             should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.
    268             </para>
    269             </remarks>
    270         </member>
    271         <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">
    272             <summary>
    273             Render <paramref name="obj"/> using the appropriate renderer.
    274             </summary>
    275             <param name="obj">the object to render to a string</param>
    276             <param name="writer">The writer to render to</param>
    277             <remarks>
    278             <para>
    279             Find the appropriate renderer for the type of the
    280             <paramref name="obj"/> parameter. This is accomplished by calling the
    281             <see cref="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)"/> method. Once a renderer is found, it is
    282             applied on the object <paramref name="obj"/> and the result is returned
    283             as a <see cref="T:System.String"/>.
    284             </para>
    285             </remarks>
    286         </member>
    287         <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">
    288             <summary>
    289             Gets the renderer for the specified object type
    290             </summary>
    291             <param name="obj">the object to lookup the renderer for</param>
    292             <returns>the renderer for <paramref name="obj"/></returns>
    293             <remarks>
    294             <param>
    295             Gets the renderer for the specified object type.
    296             </param>
    297             <param>
    298             Syntactic sugar method that calls <see cref="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)"/>
    299             with the type of the object parameter.
    300             </param>
    301             </remarks>
    302         </member>
    303         <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">
    304             <summary>
    305             Gets the renderer for the specified type
    306             </summary>
    307             <param name="type">the type to lookup the renderer for</param>
    308             <returns>the renderer for the specified type</returns>
    309             <remarks>
    310             <para>
    311             Returns the renderer for the specified type.
    312             If no specific renderer has been defined the
    313             <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.
    314             </para>
    315             </remarks>
    316         </member>
    317         <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">
    318             <summary>
    319             Internal function to recursively search interfaces
    320             </summary>
    321             <param name="type">the type to lookup the renderer for</param>
    322             <returns>the renderer for the specified type</returns>
    323         </member>
    324         <member name="M:log4net.ObjectRenderer.RendererMap.Clear">
    325             <summary>
    326             Clear the map of renderers
    327             </summary>
    328             <remarks>
    329             <para>
    330             Clear the custom renderers defined by using
    331             <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>
    332             cannot be removed.
    333             </para>
    334             </remarks>
    335         </member>
    336         <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
    337             <summary>
    338             Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>.
    339             </summary>
    340             <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>
    341             <param name="renderer">the renderer for <paramref name="typeToRender"/></param>
    342             <remarks>
    343             <para>
    344             Register an object renderer for a specific source type.
    345             This renderer will be returned from a call to <see cref="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)"/>
    346             specifying the same <paramref name="typeToRender"/> as an argument.
    347             </para>
    348             </remarks>
    349         </member>
    350         <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">
    351             <summary>
    352             Get the default renderer instance
    353             </summary>
    354             <value>the default renderer</value>
    355             <remarks>
    356             <para>
    357             Get the default renderer
    358             </para>
    359             </remarks>
    360         </member>
    361         <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">
    362             <summary>
    363             Converter to output the relative time of the event
    364             </summary>
    365             <remarks>
    366             <para>
    367             Converter to output the time of the event relative to the start of the program.
    368             </para>
    369             </remarks>
    370             <author>Nicko Cadell</author>
    371         </member>
    372         <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">
    373             <summary>
    374             Abstract class that provides the formatting functionality that
    375             derived classes need.
    376             </summary>
    377             <remarks>
    378             Conversion specifiers in a conversion patterns are parsed to
    379             individual PatternConverters. Each of which is responsible for
    380             converting a logging event in a converter specific manner.
     142        </member>
     143        <member name="F:log4net.Util.TextWriterAdapter.m_writer">
     144            <summary>
     145            The writer to forward messages to
     146            </summary>
     147        </member>
     148        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">
     149            <summary>
     150            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
     151            messages to a <see cref="T:System.IO.TextWriter"/>.
     152            </summary>
     153            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>
     154            <remarks>
     155            <para>
     156            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all
     157            messages to a <see cref="T:System.IO.TextWriter"/>.
     158            </para>
     159            </remarks>
     160        </member>
     161        <member name="M:log4net.Util.TextWriterAdapter.Close">
     162            <summary>
     163            Closes the writer and releases any system resources associated with the writer
     164            </summary>
     165            <remarks>
     166            <para>
     167            </para>
     168            </remarks>
     169        </member>
     170        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">
     171            <summary>
     172            Dispose this writer
     173            </summary>
     174            <param name="disposing">flag indicating if we are being disposed</param>
     175            <remarks>
     176            <para>
     177            Dispose this writer
     178            </para>
     179            </remarks>
     180        </member>
     181        <member name="M:log4net.Util.TextWriterAdapter.Flush">
     182            <summary>
     183            Flushes any buffered output
     184            </summary>
     185            <remarks>
     186            <para>
     187            Clears all buffers for the writer and causes any buffered data to be written
     188            to the underlying device
     189            </para>
     190            </remarks>
     191        </member>
     192        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">
     193            <summary>
     194            Writes a character to the wrapped TextWriter
     195            </summary>
     196            <param name="value">the value to write to the TextWriter</param>
     197            <remarks>
     198            <para>
     199            Writes a character to the wrapped TextWriter
     200            </para>
     201            </remarks>
     202        </member>
     203        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">
     204            <summary>
     205            Writes a character buffer to the wrapped TextWriter
     206            </summary>
     207            <param name="buffer">the data buffer</param>
     208            <param name="index">the start index</param>
     209            <param name="count">the number of characters to write</param>
     210            <remarks>
     211            <para>
     212            Writes a character buffer to the wrapped TextWriter
     213            </para>
     214            </remarks>
     215        </member>
     216        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">
     217            <summary>
     218            Writes a string to the wrapped TextWriter
     219            </summary>
     220            <param name="value">the value to write to the TextWriter</param>
     221            <remarks>
     222            <para>
     223            Writes a string to the wrapped TextWriter
     224            </para>
     225            </remarks>
     226        </member>
     227        <member name="P:log4net.Util.TextWriterAdapter.Writer">
     228            <summary>
     229            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
     230            </summary>
     231            <value>
     232            The underlying <see cref="T:System.IO.TextWriter"/>.
     233            </value>
     234            <remarks>
     235            <para>
     236            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.
     237            </para>
     238            </remarks>
     239        </member>
     240        <member name="P:log4net.Util.TextWriterAdapter.Encoding">
     241            <summary>
     242            The Encoding in which the output is written
     243            </summary>
     244            <value>
     245            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>
     246            </value>
     247            <remarks>
     248            <para>
     249            The Encoding in which the output is written
     250            </para>
     251            </remarks>
     252        </member>
     253        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">
     254            <summary>
     255            Gets an object that controls formatting
     256            </summary>
     257            <value>
     258            The format provider
     259            </value>
     260            <remarks>
     261            <para>
     262            Gets an object that controls formatting
     263            </para>
     264            </remarks>
     265        </member>
     266        <member name="P:log4net.Util.TextWriterAdapter.NewLine">
     267            <summary>
     268            Gets or sets the line terminator string used by the TextWriter
     269            </summary>
     270            <value>
     271            The line terminator to use
     272            </value>
     273            <remarks>
     274            <para>
     275            Gets or sets the line terminator string used by the TextWriter
     276            </para>
     277            </remarks>
     278        </member>
     279        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">
     280            <summary>
     281            Pattern converter for literal string instances in the pattern
     282            </summary>
     283            <remarks>
     284            <para>
     285            Writes the literal string value specified in the
     286            <see cref="P:log4net.Util.PatternConverter.Option"/> property to
     287            the output.
     288            </para>
    381289            </remarks>
    382290            <author>Nicko Cadell</author>
     
    549457            </para>
    550458            </remarks>
    551         </member>
    552         <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">
    553             <summary>
    554             Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.
    555             </summary>
    556         </member>
    557         <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    558             <summary>
    559             Derived pattern converters must override this method in order to
    560             convert conversion specifiers in the correct way.
    561             </summary>
    562             <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
    563             <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>
    564         </member>
    565         <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">
    566             <summary>
    567             Derived pattern converters must override this method in order to
    568             convert conversion specifiers in the correct way.
    569             </summary>
    570             <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
    571             <param name="state">The state object on which the pattern converter should be executed.</param>
    572         </member>
    573         <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">
    574             <summary>
    575             Flag indicating if this converter handles exceptions
    576             </summary>
    577             <remarks>
    578             <c>false</c> if this converter handles exceptions
    579             </remarks>
    580         </member>
    581         <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">
    582             <summary>
    583             Flag indicating if this converter handles the logging event exception
    584             </summary>
    585             <value><c>false</c> if this converter handles the logging event exception</value>
    586             <remarks>
    587             <para>
    588             If this converter handles the exception object contained within
    589             <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to
    590             <c>false</c>. Otherwise, if the layout ignores the exception
    591             object, then the property should be set to <c>true</c>.
    592             </para>
    593             <para>
    594             Set this value to override a this default setting. The default
    595             value is <c>true</c>, this converter does not handle the exception.
    596             </para>
    597             </remarks>
    598         </member>
    599         <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    600             <summary>
    601             Write the relative time to the output
    602             </summary>
    603             <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
    604             <param name="loggingEvent">the event being logged</param>
    605             <remarks>
    606             <para>
    607             Writes out the relative time of the event in milliseconds.
    608             That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>
    609             and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.
    610             </para>
    611             </remarks>
    612         </member>
    613         <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">
    614             <summary>
    615             Helper method to get the time difference between two DateTime objects
    616             </summary>
    617             <param name="start">start time (in the current local time zone)</param>
    618             <param name="end">end time (in the current local time zone)</param>
    619             <returns>the time difference in milliseconds</returns>
    620         </member>
    621         <member name="T:log4net.Layout.Pattern.LevelPatternConverter">
    622             <summary>
    623             Write the event level to the output
    624             </summary>
    625             <remarks>
    626             <para>
    627             Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>
    628             to the writer.
    629             </para>
    630             </remarks>
    631             <author>Nicko Cadell</author>
    632         </member>
    633         <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    634             <summary>
    635             Write the event level to the output
    636             </summary>
    637             <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
    638             <param name="loggingEvent">the event being logged</param>
    639             <remarks>
    640             <para>
    641             Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>
    642             to the <paramref name="writer"/>.
    643             </para>
    644             </remarks>
    645         </member>
    646         <member name="T:log4net.Appender.TextWriterAppender">
    647             <summary>
    648             Sends logging events to a <see cref="T:System.IO.TextWriter"/>.
    649             </summary>
    650             <remarks>
    651             <para>
    652             An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.
    653             </para>
    654             <para>
    655             This appender may be used stand alone if initialized with an appropriate
    656             writer, however it is typically used as a base class for an appender that
    657             can open a <see cref="T:System.IO.TextWriter"/> to write to.
    658             </para>
    659             </remarks>
    660             <author>Nicko Cadell</author>
    661             <author>Gert Driesen</author>
    662             <author>Douglas de la Torre</author>
    663         </member>
    664         <member name="T:log4net.Appender.AppenderSkeleton">
    665             <summary>
    666             Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>.
    667             </summary>
    668             <remarks>
    669             <para>
    670             This class provides the code for common functionality, such
    671             as support for threshold filtering and support for general filters.
    672             </para>
    673             <para>
    674             Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
    675             they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
    676             be called after the appenders properties have been configured.
    677             </para>
    678             </remarks>
    679             <author>Nicko Cadell</author>
    680             <author>Gert Driesen</author>
    681         </member>
    682         <member name="T:log4net.Appender.IAppender">
    683             <summary>
    684             Implement this interface for your own strategies for printing log statements.
    685             </summary>
    686             <remarks>
    687             <para>
    688             Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
    689             class which provides a default implementation of this interface.
    690             </para>
    691             <para>
    692             Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
    693             they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
    694             be called after the appenders properties have been configured.
    695             </para>
    696             </remarks>
    697             <author>Nicko Cadell</author>
    698             <author>Gert Driesen</author>
    699         </member>
    700         <member name="M:log4net.Appender.IAppender.Close">
    701             <summary>
    702             Closes the appender and releases resources.
    703             </summary>
    704             <remarks>
    705             <para>
    706             Releases any resources allocated within the appender such as file handles,
    707             network connections, etc.
    708             </para>
    709             <para>
    710             It is a programming error to append to a closed appender.
    711             </para>
    712             </remarks>
    713         </member>
    714         <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
    715             <summary>
    716             Log the logging event in Appender specific way.
    717             </summary>
    718             <param name="loggingEvent">The event to log</param>
    719             <remarks>
    720             <para>
    721             This method is called to log a message into this appender.
    722             </para>
    723             </remarks>
    724         </member>
    725         <member name="P:log4net.Appender.IAppender.Name">
    726             <summary>
    727             Gets or sets the name of this appender.
    728             </summary>
    729             <value>The name of the appender.</value>
    730             <remarks>
    731             <para>The name uniquely identifies the appender.</para>
    732             </remarks>
    733         </member>
    734         <member name="T:log4net.Appender.IBulkAppender">
    735             <summary>
    736             Interface for appenders that support bulk logging.
    737             </summary>
    738             <remarks>
    739             <para>
    740             This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
    741             support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
    742             should only implement this interface if they can bulk log efficiently.
    743             </para>
    744             </remarks>
    745             <author>Nicko Cadell</author>
    746         </member>
    747         <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
    748             <summary>
    749             Log the array of logging events in Appender specific way.
    750             </summary>
    751             <param name="loggingEvents">The events to log</param>
    752             <remarks>
    753             <para>
    754             This method is called to log an array of events into this appender.
    755             </para>
    756             </remarks>
    757         </member>
    758         <member name="T:log4net.Core.IOptionHandler">
    759             <summary>
    760             Interface used to delay activate a configured object.
    761             </summary>
    762             <remarks>
    763             <para>
    764             This allows an object to defer activation of its options until all
    765             options have been set. This is required for components which have
    766             related options that remain ambiguous until all are set.
    767             </para>
    768             <para>
    769             If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
    770             must be called by the container after its all the configured properties have been set
    771             and before the component can be used.
    772             </para>
    773             </remarks>
    774             <author>Nicko Cadell</author>
    775         </member>
    776         <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
    777             <summary>
    778             Activate the options that were previously set with calls to properties.
    779             </summary>
    780             <remarks>
    781             <para>
    782             This allows an object to defer activation of its options until all
    783             options have been set. This is required for components which have
    784             related options that remain ambiguous until all are set.
    785             </para>
    786             <para>
    787             If a component implements this interface then this method must be called
    788             after its properties have been set before the component can be used.
    789             </para>
    790             </remarks>
    791         </member>
    792         <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
    793             <summary>
    794             Initial buffer size
    795             </summary>
    796         </member>
    797         <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
    798             <summary>
    799             Maximum buffer size before it is recycled
    800             </summary>
    801         </member>
    802         <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
    803             <summary>
    804             Default constructor
    805             </summary>
    806             <remarks>
    807             <para>Empty default constructor</para>
    808             </remarks>
    809         </member>
    810         <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
    811             <summary>
    812             Finalizes this appender by calling the implementation's
    813             <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
    814             </summary>
    815             <remarks>
    816             <para>
    817             If this appender has not been closed then the <c>Finalize</c> method
    818             will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
    819             </para>
    820             </remarks>
    821         </member>
    822         <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
    823             <summary>
    824             Initialize the appender based on the options set
    825             </summary>
    826             <remarks>
    827             <para>
    828             This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
    829             activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must
    830             be called on this object after the configuration properties have
    831             been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
    832             object is in an undefined state and must not be used.
    833             </para>
    834             <para>
    835             If any of the configuration properties are modified then
    836             <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
    837             </para>
    838             </remarks>
    839         </member>
    840         <member name="M:log4net.Appender.AppenderSkeleton.Close">
    841             <summary>
    842             Closes the appender and release resources.
    843             </summary>
    844             <remarks>
    845             <para>
    846             Release any resources allocated within the appender such as file handles,
    847             network connections, etc.
    848             </para>
    849             <para>
    850             It is a programming error to append to a closed appender.
    851             </para>
    852             <para>
    853             This method cannot be overridden by subclasses. This method
    854             delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
    855             method which must be overridden in the subclass.
    856             </para>
    857             </remarks>
    858         </member>
    859         <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
    860             <summary>
    861             Performs threshold checks and invokes filters before
    862             delegating actual logging to the subclasses specific
    863             <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
    864             </summary>
    865             <param name="loggingEvent">The event to log.</param>
    866             <remarks>
    867             <para>
    868             This method cannot be overridden by derived classes. A
    869             derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method
    870             which is called by this method.
    871             </para>
    872             <para>
    873             The implementation of this method is as follows:
    874             </para>
    875             <para>
    876             <list type="bullet">
    877                 <item>
    878                         <description>
    879                         Checks that the severity of the <paramref name="loggingEvent"/>
    880                         is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
    881                         appender.</description>
    882                 </item>
    883                 <item>
    884                         <description>
    885                         Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the
    886                         <paramref name="loggingEvent"/>.
    887                         </description>
    888                 </item>
    889                 <item>
    890                         <description>
    891                         Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that
    892                         it returns <c>true</c>.</description>
    893                 </item>
    894             </list>
    895             </para>
    896             <para>
    897             If all of the above steps succeed then the <paramref name="loggingEvent"/>
    898             will be passed to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
    899             </para>
    900             </remarks>
    901         </member>
    902         <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
    903             <summary>
    904             Performs threshold checks and invokes filters before
    905             delegating actual logging to the subclasses specific
    906             <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.
    907             </summary>
    908             <param name="loggingEvents">The array of events to log.</param>
    909             <remarks>
    910             <para>
    911             This method cannot be overridden by derived classes. A
    912             derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method
    913             which is called by this method.
    914             </para>
    915             <para>
    916             The implementation of this method is as follows:
    917             </para>
    918             <para>
    919             <list type="bullet">
    920                 <item>
    921                         <description>
    922                         Checks that the severity of the <paramref name="loggingEvent"/>
    923                         is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
    924                         appender.</description>
    925                 </item>
    926                 <item>
    927                         <description>
    928                         Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the
    929                         <paramref name="loggingEvent"/>.
    930                         </description>
    931                 </item>
    932                 <item>
    933                         <description>
    934                         Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that
    935                         it returns <c>true</c>.</description>
    936                 </item>
    937             </list>
    938             </para>
    939             <para>
    940             If all of the above steps succeed then the <paramref name="loggingEvents"/>
    941             will be passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.
    942             </para>
    943             </remarks>
    944         </member>
    945         <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
    946             <summary>
    947             Test if the logging event should we output by this appender
    948             </summary>
    949             <param name="loggingEvent">the event to test</param>
    950             <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
    951             <remarks>
    952             <para>
    953             This method checks the logging event against the threshold level set
    954             on this appender and also against the filters specified on this
    955             appender.
    956             </para>
    957             <para>
    958             The implementation of this method is as follows:
    959             </para>
    960             <para>
    961             <list type="bullet">
    962                 <item>
    963                         <description>
    964                         Checks that the severity of the <paramref name="loggingEvent"/>
    965                         is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
    966                         appender.</description>
    967                 </item>
    968                 <item>
    969                         <description>
    970                         Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the
    971                         <paramref name="loggingEvent"/>.
    972                         </description>
    973                 </item>
    974             </list>
    975             </para>
    976             </remarks>
    977         </member>
    978         <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
    979             <summary>
    980             Adds a filter to the end of the filter chain.
    981             </summary>
    982             <param name="filter">the filter to add to this appender</param>
    983             <remarks>
    984             <para>
    985             The Filters are organized in a linked list.
    986             </para>
    987             <para>
    988             Setting this property causes the new filter to be pushed onto the
    989             back of the filter chain.
    990             </para>
    991             </remarks>
    992         </member>
    993         <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
    994             <summary>
    995             Clears the filter list for this appender.
    996             </summary>
    997             <remarks>
    998             <para>
    999             Clears the filter list for this appender.
    1000             </para>
    1001             </remarks>
    1002         </member>
    1003         <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
    1004             <summary>
    1005             Checks if the message level is below this appender's threshold.
    1006             </summary>
    1007             <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
    1008             <remarks>
    1009             <para>
    1010             If there is no threshold set, then the return value is always <c>true</c>.
    1011             </para>
    1012             </remarks>
    1013             <returns>
    1014             <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/>
    1015             requirements of this appender.
    1016             </returns>
    1017         </member>
    1018         <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
    1019             <summary>
    1020             Is called when the appender is closed. Derived classes should override
    1021             this method if resources need to be released.
    1022             </summary>
    1023             <remarks>
    1024             <para>
    1025             Releases any resources allocated within the appender such as file handles,
    1026             network connections, etc.
    1027             </para>
    1028             <para>
    1029             It is a programming error to append to a closed appender.
    1030             </para>
    1031             </remarks>
    1032         </member>
    1033         <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
    1034             <summary>
    1035             Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method
    1036             to perform actual logging.
    1037             </summary>
    1038             <param name="loggingEvent">The event to append.</param>
    1039             <remarks>
    1040             <para>
    1041             A subclass must implement this method to perform
    1042             logging of the <paramref name="loggingEvent"/>.
    1043             </para>
    1044             <para>This method will be called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
    1045             if all the conditions listed for that method are met.
    1046             </para>
    1047             <para>
    1048             To restrict the logging of events in the appender
    1049             override the <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> method.
    1050             </para>
    1051             </remarks>
    1052         </member>
    1053         <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
    1054             <summary>
    1055             Append a bulk array of logging events.
    1056             </summary>
    1057             <param name="loggingEvents">the array of logging events</param>
    1058             <remarks>
    1059             <para>
    1060             This base class implementation calls the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>
    1061             method for each element in the bulk array.
    1062             </para>
    1063             <para>
    1064             A sub class that can better process a bulk array of events should
    1065             override this method in addition to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>.
    1066             </para>
    1067             </remarks>
    1068         </member>
    1069         <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
    1070             <summary>
    1071             Called before <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> as a precondition.
    1072             </summary>
    1073             <remarks>
    1074             <para>
    1075             This method is called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
    1076             before the call to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
    1077             </para>
    1078             <para>
    1079             This method can be overridden in a subclass to extend the checks
    1080             made before the event is passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
    1081             </para>
    1082             <para>
    1083             A subclass should ensure that they delegate this call to
    1084             this base class if it is overridden.
    1085             </para>
    1086             </remarks>
    1087             <returns><c>true</c> if the call to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> should proceed.</returns>
    1088         </member>
    1089         <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
    1090             <summary>
    1091             Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
    1092             </summary>
    1093             <param name="loggingEvent">The event to render.</param>
    1094             <returns>The event rendered as a string.</returns>
    1095             <remarks>
    1096             <para>
    1097             Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to
    1098             a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
    1099             set to render the <paramref name="loggingEvent"/> to
    1100             a string.
    1101             </para>
    1102             <para>If there is exception data in the logging event and
    1103             the layout does not process the exception, this method
    1104             will append the exception text to the rendered string.
    1105             </para>
    1106             <para>
    1107             Where possible use the alternative version of this method
    1108             <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)"/>.
    1109             That method streams the rendering onto an existing Writer
    1110             which can give better performance if the caller already has
    1111             a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
    1112             </para>
    1113             </remarks>
    1114         </member>
    1115         <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    1116             <summary>
    1117             Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
    1118             </summary>
    1119             <param name="loggingEvent">The event to render.</param>
    1120             <param name="writer">The TextWriter to write the formatted event to</param>
    1121             <remarks>
    1122             <para>
    1123             Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to
    1124             a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
    1125             set to render the <paramref name="loggingEvent"/> to
    1126             a string.
    1127             </para>
    1128             <para>If there is exception data in the logging event and
    1129             the layout does not process the exception, this method
    1130             will append the exception text to the rendered string.
    1131             </para>
    1132             <para>
    1133             Use this method in preference to <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/>
    1134             where possible. If, however, the caller needs to render the event
    1135             to a string then <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/> does
    1136             provide an efficient mechanism for doing so.
    1137             </para>
    1138             </remarks>
    1139         </member>
    1140         <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
    1141             <summary>
    1142             The layout of this appender.
    1143             </summary>
    1144             <remarks>
    1145             See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
    1146             </remarks>
    1147         </member>
    1148         <member name="F:log4net.Appender.AppenderSkeleton.m_name">
    1149             <summary>
    1150             The name of this appender.
    1151             </summary>
    1152             <remarks>
    1153             See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
    1154             </remarks>
    1155         </member>
    1156         <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
    1157             <summary>
    1158             The level threshold of this appender.
    1159             </summary>
    1160             <remarks>
    1161             <para>
    1162             There is no level threshold filtering by default.
    1163             </para>
    1164             <para>
    1165             See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
    1166             </para>
    1167             </remarks>
    1168         </member>
    1169         <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
    1170             <summary>
    1171             It is assumed and enforced that errorHandler is never null.
    1172             </summary>
    1173             <remarks>
    1174             <para>
    1175             It is assumed and enforced that errorHandler is never null.
    1176             </para>
    1177             <para>
    1178             See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
    1179             </para>
    1180             </remarks>
    1181         </member>
    1182         <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
    1183             <summary>
    1184             The first filter in the filter chain.
    1185             </summary>
    1186             <remarks>
    1187             <para>
    1188             Set to <c>null</c> initially.
    1189             </para>
    1190             <para>
    1191             See <see cref="T:log4net.Filter.IFilter"/> for more information.
    1192             </para>
    1193             </remarks>
    1194         </member>
    1195         <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
    1196             <summary>
    1197             The last filter in the filter chain.
    1198             </summary>
    1199             <remarks>
    1200             See <see cref="T:log4net.Filter.IFilter"/> for more information.
    1201             </remarks>
    1202         </member>
    1203         <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
    1204             <summary>
    1205             Flag indicating if this appender is closed.
    1206             </summary>
    1207             <remarks>
    1208             See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
    1209             </remarks>
    1210         </member>
    1211         <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
    1212             <summary>
    1213             The guard prevents an appender from repeatedly calling its own DoAppend method
    1214             </summary>
    1215         </member>
    1216         <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
    1217             <summary>
    1218             StringWriter used to render events
    1219             </summary>
    1220         </member>
    1221         <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
    1222             <summary>
    1223             Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
    1224             </summary>
    1225             <value>
    1226             The threshold <see cref="T:log4net.Core.Level"/> of the appender.
    1227             </value>
    1228             <remarks>
    1229             <para>
    1230             All log events with lower level than the threshold level are ignored
    1231             by the appender.
    1232             </para>
    1233             <para>
    1234             In configuration files this option is specified by setting the
    1235             value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
    1236             string, such as "DEBUG", "INFO" and so on.
    1237             </para>
    1238             </remarks>
    1239         </member>
    1240         <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
    1241             <summary>
    1242             Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
    1243             </summary>
    1244             <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
    1245             <remarks>
    1246             <para>
    1247             The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default
    1248             implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property.
    1249             </para>
    1250             </remarks>
    1251         </member>
    1252         <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
    1253             <summary>
    1254             The filter chain.
    1255             </summary>
    1256             <value>The head of the filter chain filter chain.</value>
    1257             <remarks>
    1258             <para>
    1259             Returns the head Filter. The Filters are organized in a linked list
    1260             and so all Filters on this Appender are available through the result.
    1261             </para>
    1262             </remarks>
    1263         </member>
    1264         <member name="P:log4net.Appender.AppenderSkeleton.Layout">
    1265             <summary>
    1266             Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
    1267             </summary>
    1268             <value>The layout of the appender.</value>
    1269             <remarks>
    1270             <para>
    1271             See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
    1272             </para>
    1273             </remarks>
    1274             <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
    1275         </member>
    1276         <member name="P:log4net.Appender.AppenderSkeleton.Name">
    1277             <summary>
    1278             Gets or sets the name of this appender.
    1279             </summary>
    1280             <value>The name of the appender.</value>
    1281             <remarks>
    1282             <para>
    1283             The name uniquely identifies the appender.
    1284             </para>
    1285             </remarks>
    1286         </member>
    1287         <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
    1288             <summary>
    1289             Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
    1290             </summary>
    1291             <remarks>
    1292             <para>
    1293             In the rather exceptional case, where the appender
    1294             implementation admits a layout but can also work without it,
    1295             then the appender should return <c>true</c>.
    1296             </para>
    1297             <para>
    1298             This default implementation always returns <c>true</c>.
    1299             </para>
    1300             </remarks>
    1301             <returns>
    1302             <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
    1303             </returns>
    1304         </member>
    1305         <member name="M:log4net.Appender.TextWriterAppender.#ctor">
    1306             <summary>
    1307             Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.
    1308             </summary>
    1309             <remarks>
    1310             <para>
    1311             Default constructor.
    1312             </para>
    1313             </remarks>
    1314         </member>
    1315         <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">
    1316             <summary>
    1317             Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and
    1318             sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized
    1319             with the specified <see cref="T:System.IO.Stream"/>.
    1320             </summary>
    1321             <param name="layout">The layout to use with this appender.</param>
    1322             <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>
    1323             <remarks>
    1324             <para>
    1325             Obsolete constructor.
    1326             </para>
    1327             </remarks>
    1328         </member>
    1329         <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">
    1330             <summary>
    1331             Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets
    1332             the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.
    1333             </summary>
    1334             <param name="layout">The layout to use with this appender</param>
    1335             <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>
    1336             <remarks>
    1337             The <see cref="T:System.IO.TextWriter"/> must have been previously opened.
    1338             </remarks>
    1339             <remarks>
    1340             <para>
    1341             Obsolete constructor.
    1342             </para>
    1343             </remarks>
    1344         </member>
    1345         <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">
    1346             <summary>
    1347             This method determines if there is a sense in attempting to append.
    1348             </summary>
    1349             <remarks>
    1350             <para>
    1351             This method checked if an output target has been set and if a
    1352             layout has been set.
    1353             </para>
    1354             </remarks>
    1355             <returns><c>false</c> if any of the preconditions fail.</returns>
    1356         </member>
    1357         <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">
    1358             <summary>
    1359             This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
    1360             method.
    1361             </summary>
    1362             <param name="loggingEvent">The event to log.</param>
    1363             <remarks>
    1364             <para>
    1365             Writes a log statement to the output stream if the output stream exists
    1366             and is writable. 
    1367             </para>
    1368             <para>
    1369             The format of the output will depend on the appender's layout.
    1370             </para>
    1371             </remarks>
    1372         </member>
    1373         <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">
    1374             <summary>
    1375             This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])"/>
    1376             method.
    1377             </summary>
    1378             <param name="loggingEvents">The array of events to log.</param>
    1379             <remarks>
    1380             <para>
    1381             This method writes all the bulk logged events to the output writer
    1382             before flushing the stream.
    1383             </para>
    1384             </remarks>
    1385         </member>
    1386         <member name="M:log4net.Appender.TextWriterAppender.OnClose">
    1387             <summary>
    1388             Close this appender instance. The underlying stream or writer is also closed.
    1389             </summary>
    1390             <remarks>
    1391             Closed appenders cannot be reused.
    1392             </remarks>
    1393         </member>
    1394         <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">
    1395             <summary>
    1396             Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
    1397             </summary>
    1398             <remarks>
    1399             <para>
    1400             Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.
    1401             </para>
    1402             </remarks>
    1403         </member>
    1404         <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">
    1405             <summary>
    1406             Closes the underlying <see cref="T:System.IO.TextWriter"/>.
    1407             </summary>
    1408             <remarks>
    1409             <para>
    1410             Closes the underlying <see cref="T:System.IO.TextWriter"/>.
    1411             </para>
    1412             </remarks>
    1413         </member>
    1414         <member name="M:log4net.Appender.TextWriterAppender.Reset">
    1415             <summary>
    1416             Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/>
    1417             and other variables.
    1418             </summary>
    1419             <remarks>
    1420             <para>
    1421             Subclasses can override this method for an alternate closing behavior.
    1422             </para>
    1423             </remarks>
    1424         </member>
    1425         <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">
    1426             <summary>
    1427             Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
    1428             </summary>
    1429             <remarks>
    1430             <para>
    1431             Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.
    1432             </para>
    1433             </remarks>
    1434         </member>
    1435         <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">
    1436             <summary>
    1437             Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
    1438             </summary>
    1439             <remarks>
    1440             <para>
    1441             Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.
    1442             </para>
    1443             </remarks>
    1444         </member>
    1445         <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">
    1446             <summary>
    1447             Called to allow a subclass to lazily initialize the writer
    1448             </summary>
    1449             <remarks>
    1450             <para>
    1451             This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or
    1452             <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to
    1453             attempt to initialize the writer multiple times.
    1454             </para>
    1455             </remarks>
    1456         </member>
    1457         <member name="F:log4net.Appender.TextWriterAppender.m_qtw">
    1458             <summary>
    1459             This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
    1460             will be written to.
    1461             </summary>
    1462         </member>
    1463         <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">
    1464             <summary>
    1465             Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/>
    1466             or output stream will be flushed at the end of each append operation.
    1467             </summary>
    1468             <remarks>
    1469             <para>
    1470             Immediate flush is slower but ensures that each append request is
    1471             actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to
    1472             <c>false</c>, then there is a good chance that the last few
    1473             logging events are not actually persisted if and when the application
    1474             crashes.
    1475             </para>
    1476             <para>
    1477             The default value is <c>true</c>.
    1478             </para>
    1479             </remarks>
    1480         </member>
    1481         <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">
    1482             <summary>
    1483             Gets or set whether the appender will flush at the end
    1484             of each append operation.
    1485             </summary>
    1486             <value>
    1487             <para>
    1488             The default behavior is to flush at the end of each
    1489             append operation.
    1490             </para>
    1491             <para>
    1492             If this option is set to <c>false</c>, then the underlying
    1493             stream can defer persisting the logging event to a later
    1494             time.
    1495             </para>
    1496             </value>
    1497             <remarks>
    1498             Avoiding the flush operation at the end of each append results in
    1499             a performance gain of 10 to 20 percent. However, there is safety
    1500             trade-off involved in skipping flushing. Indeed, when flushing is
    1501             skipped, then it is likely that the last few log events will not
    1502             be recorded on disk when the application exits. This is a high
    1503             price to pay even for a 20% performance gain.
    1504             </remarks>
    1505         </member>
    1506         <member name="P:log4net.Appender.TextWriterAppender.Writer">
    1507             <summary>
    1508             Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.
    1509             </summary>
    1510             <remarks>
    1511             <para>
    1512             The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.
    1513             </para>
    1514             <para>
    1515             The <see cref="T:System.IO.TextWriter"/> will be closed when the appender
    1516             instance is closed.
    1517             </para>
    1518             <para>
    1519             <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.
    1520             </para>
    1521             </remarks>
    1522         </member>
    1523         <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">
    1524             <summary>
    1525             Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying
    1526             <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender.
    1527             </summary>
    1528             <value>
    1529             The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
    1530             </value>
    1531         </member>
    1532         <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">
    1533             <summary>
    1534             This appender requires a <see cref="N:log4net.Layout"/> to be set.
    1535             </summary>
    1536             <value><c>true</c></value>
    1537             <remarks>
    1538             <para>
    1539             This appender requires a <see cref="N:log4net.Layout"/> to be set.
    1540             </para>
    1541             </remarks>
    1542         </member>
    1543         <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">
    1544             <summary>
    1545             Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
    1546             will be written to.
    1547             </summary>
    1548             <value>
    1549             The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.
    1550             </value>
    1551             <remarks>
    1552             <para>
    1553             This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events
    1554             will be written to.
    1555             </para>
    1556             </remarks>
    1557         </member>
    1558         <member name="T:log4net.Appender.MemoryAppender">
    1559             <summary>
    1560             Stores logging events in an array.
    1561             </summary>
    1562             <remarks>
    1563             <para>
    1564             The memory appender stores all the logging events
    1565             that are appended in an in-memory array.
    1566             </para>
    1567             <para>
    1568             Use the <see cref="M:log4net.Appender.MemoryAppender.GetEvents"/> method to get
    1569             the current list of events that have been appended.
    1570             </para>
    1571             <para>
    1572             Use the <see cref="M:log4net.Appender.MemoryAppender.Clear"/> method to clear the
    1573             current list of events.
    1574             </para>
    1575             </remarks>
    1576             <author>Julian Biddle</author>
    1577             <author>Nicko Cadell</author>
    1578             <author>Gert Driesen</author>
    1579         </member>
    1580         <member name="M:log4net.Appender.MemoryAppender.#ctor">
    1581             <summary>
    1582             Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.
    1583             </summary>
    1584             <remarks>
    1585             <para>
    1586             Default constructor.
    1587             </para>
    1588             </remarks>
    1589         </member>
    1590         <member name="M:log4net.Appender.MemoryAppender.GetEvents">
    1591             <summary>
    1592             Gets the events that have been logged.
    1593             </summary>
    1594             <returns>The events that have been logged</returns>
    1595             <remarks>
    1596             <para>
    1597             Gets the events that have been logged.
    1598             </para>
    1599             </remarks>
    1600         </member>
    1601         <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">
    1602             <summary>
    1603             This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.
    1604             </summary>
    1605             <param name="loggingEvent">the event to log</param>
    1606             <remarks>
    1607             <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>
    1608             </remarks>
    1609         </member>
    1610         <member name="M:log4net.Appender.MemoryAppender.Clear">
    1611             <summary>
    1612             Clear the list of events
    1613             </summary>
    1614             <remarks>
    1615             Clear the list of events
    1616             </remarks>
    1617         </member>
    1618         <member name="F:log4net.Appender.MemoryAppender.m_eventsList">
    1619             <summary>
    1620             The list of events that have been appended.
    1621             </summary>
    1622         </member>
    1623         <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">
    1624             <summary>
    1625             Value indicating which fields in the event should be fixed
    1626             </summary>
    1627             <remarks>
    1628             By default all fields are fixed
    1629             </remarks>
    1630         </member>
    1631         <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">
    1632             <summary>
    1633             Gets or sets a value indicating whether only part of the logging event
    1634             data should be fixed.
    1635             </summary>
    1636             <value>
    1637             <c>true</c> if the appender should only fix part of the logging event
    1638             data, otherwise <c>false</c>. The default is <c>false</c>.
    1639             </value>
    1640             <remarks>
    1641             <para>
    1642             Setting this property to <c>true</c> will cause only part of the event
    1643             data to be fixed and stored in the appender, hereby improving performance.
    1644             </para>
    1645             <para>
    1646             See <see cref="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)"/> for more information.
    1647             </para>
    1648             </remarks>
    1649         </member>
    1650         <member name="P:log4net.Appender.MemoryAppender.Fix">
    1651             <summary>
    1652             Gets or sets the fields that will be fixed in the event
    1653             </summary>
    1654             <remarks>
    1655             <para>
    1656             The logging event needs to have certain thread specific values
    1657             captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
    1658             for details.
    1659             </para>
    1660             </remarks>
    1661         </member>
    1662         <member name="T:log4net.Util.TypeConverters.BooleanConverter">
    1663             <summary>
    1664             Type converter for Boolean.
    1665             </summary>
    1666             <remarks>
    1667             <para>
    1668             Supports conversion from string to <c>bool</c> type.
    1669             </para>
    1670             </remarks>
    1671             <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>
    1672             <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>
    1673             <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>
    1674             <author>Nicko Cadell</author>
    1675             <author>Gert Driesen</author>
    1676         </member>
    1677         <member name="T:log4net.Util.TypeConverters.IConvertFrom">
    1678             <summary>
    1679             Interface supported by type converters
    1680             </summary>
    1681             <remarks>
    1682             <para>
    1683             This interface supports conversion from arbitrary types
    1684             to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.
    1685             </para>
    1686             </remarks>
    1687             <author>Nicko Cadell</author>
    1688             <author>Gert Driesen</author>
    1689         </member>
    1690         <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">
    1691             <summary>
    1692             Can the source type be converted to the type supported by this object
    1693             </summary>
    1694             <param name="sourceType">the type to convert</param>
    1695             <returns>true if the conversion is possible</returns>
    1696             <remarks>
    1697             <para>
    1698             Test if the <paramref name="sourceType"/> can be converted to the
    1699             type supported by this converter.
    1700             </para>
    1701             </remarks>
    1702         </member>
    1703         <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">
    1704             <summary>
    1705             Convert the source object to the type supported by this object
    1706             </summary>
    1707             <param name="source">the object to convert</param>
    1708             <returns>the converted object</returns>
    1709             <remarks>
    1710             <para>
    1711             Converts the <paramref name="source"/> to the type supported
    1712             by this converter.
    1713             </para>
    1714             </remarks>
    1715         </member>
    1716         <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">
    1717             <summary>
    1718             Can the source type be converted to the type supported by this object
    1719             </summary>
    1720             <param name="sourceType">the type to convert</param>
    1721             <returns>true if the conversion is possible</returns>
    1722             <remarks>
    1723             <para>
    1724             Returns <c>true</c> if the <paramref name="sourceType"/> is
    1725             the <see cref="T:System.String"/> type.
    1726             </para>
    1727             </remarks>
    1728         </member>
    1729         <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">
    1730             <summary>
    1731             Convert the source object to the type supported by this object
    1732             </summary>
    1733             <param name="source">the object to convert</param>
    1734             <returns>the converted object</returns>
    1735             <remarks>
    1736             <para>
    1737             Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the
    1738             <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.
    1739             </para>
    1740             </remarks>
    1741             <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
    1742             The <paramref name="source"/> object cannot be converted to the
    1743             target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>
    1744             method.
    1745             </exception>
    1746         </member>
    1747         <member name="T:log4net.Util.ReusableStringWriter">
    1748             <summary>
    1749             A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused
    1750             </summary>
    1751             <remarks>
    1752             <para>
    1753             A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.
    1754             This uses a single buffer for string operations.
    1755             </para>
    1756             </remarks>
    1757             <author>Nicko Cadell</author>
    1758         </member>
    1759         <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">
    1760             <summary>
    1761             Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
    1762             </summary>
    1763             <param name="formatProvider">the format provider to use</param>
    1764             <remarks>
    1765             <para>
    1766             Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>
    1767             </para>
    1768             </remarks>
    1769         </member>
    1770         <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">
    1771             <summary>
    1772             Override Dispose to prevent closing of writer
    1773             </summary>
    1774             <param name="disposing">flag</param>
    1775             <remarks>
    1776             <para>
    1777             Override Dispose to prevent closing of writer
    1778             </para>
    1779             </remarks>
    1780         </member>
    1781         <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">
    1782             <summary>
    1783             Reset this string writer so that it can be reused.
    1784             </summary>
    1785             <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>
    1786             <param name="defaultSize">the default size to make the buffer</param>
    1787             <remarks>
    1788             <para>
    1789             Reset this string writer so that it can be reused.
    1790             The internal buffers are cleared and reset.
    1791             </para>
    1792             </remarks>
    1793         </member>
    1794         <member name="T:log4net.Util.LevelMappingEntry">
    1795             <summary>
    1796             An entry in the <see cref="T:log4net.Util.LevelMapping"/>
    1797             </summary>
    1798             <remarks>
    1799             <para>
    1800             This is an abstract base class for types that are stored in the
    1801             <see cref="T:log4net.Util.LevelMapping"/> object.
    1802             </para>
    1803             </remarks>
    1804             <author>Nicko Cadell</author>
    1805         </member>
    1806         <member name="M:log4net.Util.LevelMappingEntry.#ctor">
    1807             <summary>
    1808             Default protected constructor
    1809             </summary>
    1810             <remarks>
    1811             <para>
    1812             Default protected constructor
    1813             </para>
    1814             </remarks>
    1815         </member>
    1816         <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">
    1817             <summary>
    1818             Initialize any options defined on this entry
    1819             </summary>
    1820             <remarks>
    1821             <para>
    1822             Should be overridden by any classes that need to initialise based on their options
    1823             </para>
    1824             </remarks>
    1825         </member>
    1826         <member name="P:log4net.Util.LevelMappingEntry.Level">
    1827             <summary>
    1828             The level that is the key for this mapping
    1829             </summary>
    1830             <value>
    1831             The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping
    1832             </value>
    1833             <remarks>
    1834             <para>
    1835             Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this
    1836             mapping subclass.
    1837             </para>
    1838             </remarks>
    1839         </member>
    1840         <member name="T:log4net.Util.CyclicBuffer">
    1841             <summary>
    1842             A fixed size rolling buffer of logging events.
    1843             </summary>
    1844             <remarks>
    1845             <para>
    1846             An array backed fixed size leaky bucket.
    1847             </para>
    1848             </remarks>
    1849             <author>Nicko Cadell</author>
    1850             <author>Gert Driesen</author>
    1851         </member>
    1852         <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">
    1853             <summary>
    1854             Constructor
    1855             </summary>
    1856             <param name="maxSize">The maximum number of logging events in the buffer.</param>
    1857             <remarks>
    1858             <para>
    1859             Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with
    1860             the specified maximum number of buffered logging events.
    1861             </para>
    1862             </remarks>
    1863             <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>
    1864         </member>
    1865         <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">
    1866             <summary>
    1867             Appends a <paramref name="loggingEvent"/> to the buffer.
    1868             </summary>
    1869             <param name="loggingEvent">The event to append to the buffer.</param>
    1870             <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>
    1871             <remarks>
    1872             <para>
    1873             Append an event to the buffer. If the buffer still contains free space then
    1874             <c>null</c> is returned. If the buffer is full then an event will be dropped
    1875             to make space for the new event, the event dropped is returned.
    1876             </para>
    1877             </remarks>
    1878         </member>
    1879         <member name="M:log4net.Util.CyclicBuffer.PopOldest">
    1880             <summary>
    1881             Get and remove the oldest event in the buffer.
    1882             </summary>
    1883             <returns>The oldest logging event in the buffer</returns>
    1884             <remarks>
    1885             <para>
    1886             Gets the oldest (first) logging event in the buffer and removes it
    1887             from the buffer.
    1888             </para>
    1889             </remarks>
    1890         </member>
    1891         <member name="M:log4net.Util.CyclicBuffer.PopAll">
    1892             <summary>
    1893             Pops all the logging events from the buffer into an array.
    1894             </summary>
    1895             <returns>An array of all the logging events in the buffer.</returns>
    1896             <remarks>
    1897             <para>
    1898             Get all the events in the buffer and clear the buffer.
    1899             </para>
    1900             </remarks>
    1901         </member>
    1902         <member name="M:log4net.Util.CyclicBuffer.Clear">
    1903             <summary>
    1904             Clear the buffer
    1905             </summary>
    1906             <remarks>
    1907             <para>
    1908             Clear the buffer of all events. The events in the buffer are lost.
    1909             </para>
    1910             </remarks>
    1911         </member>
    1912         <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">
    1913             <summary>
    1914             Gets the <paramref name="i"/>th oldest event currently in the buffer.
    1915             </summary>
    1916             <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>
    1917             <remarks>
    1918             <para>
    1919             If <paramref name="i"/> is outside the range 0 to the number of events
    1920             currently in the buffer, then <c>null</c> is returned.
    1921             </para>
    1922             </remarks>
    1923         </member>
    1924         <member name="P:log4net.Util.CyclicBuffer.MaxSize">
    1925             <summary>
    1926             Gets the maximum size of the buffer.
    1927             </summary>
    1928             <value>The maximum size of the buffer.</value>
    1929             <remarks>
    1930             <para>
    1931             Gets the maximum size of the buffer
    1932             </para>
    1933             </remarks>
    1934         </member>
    1935         <member name="P:log4net.Util.CyclicBuffer.Length">
    1936             <summary>
    1937             Gets the number of logging events in the buffer.
    1938             </summary>
    1939             <value>The number of logging events in the buffer.</value>
    1940             <remarks>
    1941             <para>
    1942             This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>
    1943             (inclusive).
    1944             </para>
    1945             </remarks>
    1946         </member>
    1947         <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">
    1948             <summary>
    1949             Delegate used to handle logger creation event notifications.
    1950             </summary>
    1951             <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>
    1952             <param name="e">The <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event args that hold the <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance that has been created.</param>
    1953             <remarks>
    1954             <para>
    1955             Delegate used to handle logger creation event notifications.
    1956             </para>
    1957             </remarks>
    1958         </member>
    1959         <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">
    1960             <summary>
    1961             Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.
    1962             </summary>
    1963             <remarks>
    1964             <para>
    1965             A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a
    1966             <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.
    1967             </para>
    1968             </remarks>
    1969         </member>
    1970         <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">
    1971             <summary>
    1972             The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created
    1973             </summary>
    1974         </member>
    1975         <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">
    1976             <summary>
    1977             Constructor
    1978             </summary>
    1979             <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>
    1980             <remarks>
    1981             <para>
    1982             Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument
    1983             class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.
    1984             </para>
    1985             </remarks>
    1986         </member>
    1987         <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">
    1988             <summary>
    1989             Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
    1990             </summary>
    1991             <value>
    1992             The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
    1993             </value>
    1994             <remarks>
    1995             <para>
    1996             The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.
    1997             </para>
    1998             </remarks>
    1999         </member>
    2000         <member name="T:log4net.Repository.Hierarchy.Hierarchy">
    2001             <summary>
    2002             Hierarchical organization of loggers
    2003             </summary>
    2004             <remarks>
    2005             <para>
    2006             <i>The casual user should not have to deal with this class
    2007             directly.</i>
    2008             </para>
    2009             <para>
    2010             This class is specialized in retrieving loggers by name and
    2011             also maintaining the logger hierarchy. Implements the
    2012             <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
    2013             </para>
    2014             <para>
    2015             The structure of the logger hierarchy is maintained by the
    2016             <see cref="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)"/> method. The hierarchy is such that children
    2017             link to their parent but parents do not have any references to their
    2018             children. Moreover, loggers can be instantiated in any order, in
    2019             particular descendant before ancestor.
    2020             </para>
    2021             <para>
    2022             In case a descendant is created before a particular ancestor,
    2023             then it creates a provision node for the ancestor and adds itself
    2024             to the provision node. Other descendants of the same ancestor add
    2025             themselves to the previously created provision node.
    2026             </para>
    2027             </remarks>
    2028             <author>Nicko Cadell</author>
    2029             <author>Gert Driesen</author>
    2030         </member>
    2031         <member name="T:log4net.Repository.LoggerRepositorySkeleton">
    2032             <summary>
    2033             Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>
    2034             </summary>
    2035             <remarks>
    2036             <para>
    2037             Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
    2038             </para>
    2039             <para>
    2040             Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.
    2041             All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.
    2042             </para>
    2043             </remarks>
    2044             <author>Nicko Cadell</author>
    2045             <author>Gert Driesen</author>
    2046         </member>
    2047         <member name="T:log4net.Repository.ILoggerRepository">
    2048             <summary>
    2049             Interface implemented by logger repositories.
    2050             </summary>
    2051             <remarks>
    2052             <para>
    2053             This interface is implemented by logger repositories. e.g.
    2054             <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.
    2055             </para>
    2056             <para>
    2057             This interface is used by the <see cref="T:log4net.LogManager"/>
    2058             to obtain <see cref="T:log4net.ILog"/> interfaces.
    2059             </para>
    2060             </remarks>
    2061             <author>Nicko Cadell</author>
    2062             <author>Gert Driesen</author>
    2063         </member>
    2064         <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">
    2065             <summary>
    2066             Check if the named logger exists in the repository. If so return
    2067             its reference, otherwise returns <c>null</c>.
    2068             </summary>
    2069             <param name="name">The name of the logger to lookup</param>
    2070             <returns>The Logger object with the name specified</returns>
    2071             <remarks>
    2072             <para>
    2073             If the names logger exists it is returned, otherwise
    2074             <c>null</c> is returned.
    2075             </para>
    2076             </remarks>
    2077         </member>
    2078         <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">
    2079             <summary>
    2080             Returns all the currently defined loggers as an Array.
    2081             </summary>
    2082             <returns>All the defined loggers</returns>
    2083             <remarks>
    2084             <para>
    2085             Returns all the currently defined loggers as an Array.
    2086             </para>
    2087             </remarks>
    2088         </member>
    2089         <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">
    2090             <summary>
    2091             Returns a named logger instance
    2092             </summary>
    2093             <param name="name">The name of the logger to retrieve</param>
    2094             <returns>The logger object with the name specified</returns>
    2095             <remarks>
    2096             <para>
    2097             Returns a named logger instance.
    2098             </para>
    2099             <para>
    2100             If a logger of that name already exists, then it will be
    2101             returned.  Otherwise, a new logger will be instantiated and
    2102             then linked with its existing ancestors as well as children.
    2103             </para>
    2104             </remarks>
    2105         </member>
    2106         <member name="M:log4net.Repository.ILoggerRepository.Shutdown">
    2107             <summary>Shutdown the repository</summary>
    2108             <remarks>
    2109             <para>
    2110             Shutting down a repository will <i>safely</i> close and remove
    2111             all appenders in all loggers including the root logger.
    2112             </para>
    2113             <para>
    2114             Some appenders need to be closed before the
    2115             application exists. Otherwise, pending logging events might be
    2116             lost.
    2117             </para>
    2118             <para>
    2119             The <see cref="M:log4net.Repository.ILoggerRepository.Shutdown"/> method is careful to close nested
    2120             appenders before closing regular appenders. This is allows
    2121             configurations where a regular appender is attached to a logger
    2122             and again to a nested appender.
    2123             </para>
    2124             </remarks>
    2125         </member>
    2126         <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">
    2127             <summary>
    2128             Reset the repositories configuration to a default state
    2129             </summary>
    2130             <remarks>
    2131             <para>
    2132             Reset all values contained in this instance to their
    2133             default state.
    2134             </para>
    2135             <para>
    2136             Existing loggers are not removed. They are just reset.
    2137             </para>
    2138             <para>
    2139             This method should be used sparingly and with care as it will
    2140             block all logging until it is completed.
    2141             </para>
    2142             </remarks>
    2143         </member>
    2144         <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">
    2145             <summary>
    2146             Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.
    2147             </summary>
    2148             <param name="logEvent">the event to log</param>
    2149             <remarks>
    2150             <para>
    2151             This method should not normally be used to log.
    2152             The <see cref="T:log4net.ILog"/> interface should be used
    2153             for routine logging. This interface can be obtained
    2154             using the <see cref="M:log4net.LogManager.GetLogger(System.String)"/> method.
    2155             </para>
    2156             <para>
    2157             The <c>logEvent</c> is delivered to the appropriate logger and
    2158             that logger is then responsible for logging the event.
    2159             </para>
    2160             </remarks>
    2161         </member>
    2162         <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">
    2163             <summary>
    2164             Returns all the Appenders that are configured as an Array.
    2165             </summary>
    2166             <returns>All the Appenders</returns>
    2167             <remarks>
    2168             <para>
    2169             Returns all the Appenders that are configured as an Array.
    2170             </para>
    2171             </remarks>
    2172         </member>
    2173         <member name="P:log4net.Repository.ILoggerRepository.Name">
    2174             <summary>
    2175             The name of the repository
    2176             </summary>
    2177             <value>
    2178             The name of the repository
    2179             </value>
    2180             <remarks>
    2181             <para>
    2182             The name of the repository.
    2183             </para>
    2184             </remarks>
    2185         </member>
    2186         <member name="P:log4net.Repository.ILoggerRepository.RendererMap">
    2187             <summary>
    2188             RendererMap accesses the object renderer map for this repository.
    2189             </summary>
    2190             <value>
    2191             RendererMap accesses the object renderer map for this repository.
    2192             </value>
    2193             <remarks>
    2194             <para>
    2195             RendererMap accesses the object renderer map for this repository.
    2196             </para>
    2197             <para>
    2198             The RendererMap holds a mapping between types and
    2199             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
    2200             </para>
    2201             </remarks>
    2202         </member>
    2203         <member name="P:log4net.Repository.ILoggerRepository.PluginMap">
    2204             <summary>
    2205             The plugin map for this repository.
    2206             </summary>
    2207             <value>
    2208             The plugin map for this repository.
    2209             </value>
    2210             <remarks>
    2211             <para>
    2212             The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
    2213             that have been attached to this repository.
    2214             </para>
    2215             </remarks>
    2216         </member>
    2217         <member name="P:log4net.Repository.ILoggerRepository.LevelMap">
    2218             <summary>
    2219             Get the level map for the Repository.
    2220             </summary>
    2221             <remarks>
    2222             <para>
    2223             Get the level map for the Repository.
    2224             </para>
    2225             <para>
    2226             The level map defines the mappings between
    2227             level names and <see cref="T:log4net.Core.Level"/> objects in
    2228             this repository.
    2229             </para>
    2230             </remarks>
    2231         </member>
    2232         <member name="P:log4net.Repository.ILoggerRepository.Threshold">
    2233             <summary>
    2234             The threshold for all events in this repository
    2235             </summary>
    2236             <value>
    2237             The threshold for all events in this repository
    2238             </value>
    2239             <remarks>
    2240             <para>
    2241             The threshold for all events in this repository.
    2242             </para>
    2243             </remarks>
    2244         </member>
    2245         <member name="P:log4net.Repository.ILoggerRepository.Configured">
    2246             <summary>
    2247             Flag indicates if this repository has been configured.
    2248             </summary>
    2249             <value>
    2250             Flag indicates if this repository has been configured.
    2251             </value>
    2252             <remarks>
    2253             <para>
    2254             Flag indicates if this repository has been configured.
    2255             </para>
    2256             </remarks>
    2257         </member>
    2258         <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">
    2259             <summary>
    2260             Event to notify that the repository has been shutdown.
    2261             </summary>
    2262             <value>
    2263             Event to notify that the repository has been shutdown.
    2264             </value>
    2265             <remarks>
    2266             <para>
    2267             Event raised when the repository has been shutdown.
    2268             </para>
    2269             </remarks>
    2270         </member>
    2271         <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">
    2272             <summary>
    2273             Event to notify that the repository has had its configuration reset.
    2274             </summary>
    2275             <value>
    2276             Event to notify that the repository has had its configuration reset.
    2277             </value>
    2278             <remarks>
    2279             <para>
    2280             Event raised when the repository's configuration has been
    2281             reset to default.
    2282             </para>
    2283             </remarks>
    2284         </member>
    2285         <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">
    2286             <summary>
    2287             Event to notify that the repository has had its configuration changed.
    2288             </summary>
    2289             <value>
    2290             Event to notify that the repository has had its configuration changed.
    2291             </value>
    2292             <remarks>
    2293             <para>
    2294             Event raised when the repository's configuration has been changed.
    2295             </para>
    2296             </remarks>
    2297         </member>
    2298         <member name="P:log4net.Repository.ILoggerRepository.Properties">
    2299             <summary>
    2300             Repository specific properties
    2301             </summary>
    2302             <value>
    2303             Repository specific properties
    2304             </value>
    2305             <remarks>
    2306             <para>
    2307             These properties can be specified on a repository specific basis.
    2308             </para>
    2309             </remarks>
    2310         </member>
    2311         <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">
    2312             <summary>
    2313             Default Constructor
    2314             </summary>
    2315             <remarks>
    2316             <para>
    2317             Initializes the repository with default (empty) properties.
    2318             </para>
    2319             </remarks>
    2320         </member>
    2321         <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">
    2322             <summary>
    2323             Construct the repository using specific properties
    2324             </summary>
    2325             <param name="properties">the properties to set for this repository</param>
    2326             <remarks>
    2327             <para>
    2328             Initializes the repository with specified properties.
    2329             </para>
    2330             </remarks>
    2331         </member>
    2332         <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">
    2333             <summary>
    2334             Test if logger exists
    2335             </summary>
    2336             <param name="name">The name of the logger to lookup</param>
    2337             <returns>The Logger object with the name specified</returns>
    2338             <remarks>
    2339             <para>
    2340             Check if the named logger exists in the repository. If so return
    2341             its reference, otherwise returns <c>null</c>.
    2342             </para>
    2343             </remarks>
    2344         </member>
    2345         <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">
    2346             <summary>
    2347             Returns all the currently defined loggers in the repository
    2348             </summary>
    2349             <returns>All the defined loggers</returns>
    2350             <remarks>
    2351             <para>
    2352             Returns all the currently defined loggers in the repository as an Array.
    2353             </para>
    2354             </remarks>
    2355         </member>
    2356         <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">
    2357             <summary>
    2358             Return a new logger instance
    2359             </summary>
    2360             <param name="name">The name of the logger to retrieve</param>
    2361             <returns>The logger object with the name specified</returns>
    2362             <remarks>
    2363             <para>
    2364             Return a new logger instance.
    2365             </para>
    2366             <para>
    2367             If a logger of that name already exists, then it will be
    2368             returned. Otherwise, a new logger will be instantiated and
    2369             then linked with its existing ancestors as well as children.
    2370             </para>
    2371             </remarks>
    2372         </member>
    2373         <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">
    2374             <summary>
    2375             Shutdown the repository
    2376             </summary>
    2377             <remarks>
    2378             <para>
    2379             Shutdown the repository. Can be overridden in a subclass.
    2380             This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>
    2381             listeners and all attached plugins of the shutdown event.
    2382             </para>
    2383             </remarks>
    2384         </member>
    2385         <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">
    2386             <summary>
    2387             Reset the repositories configuration to a default state
    2388             </summary>
    2389             <remarks>
    2390             <para>
    2391             Reset all values contained in this instance to their
    2392             default state.
    2393             </para>
    2394             <para>
    2395             Existing loggers are not removed. They are just reset.
    2396             </para>
    2397             <para>
    2398             This method should be used sparingly and with care as it will
    2399             block all logging until it is completed.
    2400             </para>
    2401             </remarks>
    2402         </member>
    2403         <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">
    2404             <summary>
    2405             Log the logEvent through this repository.
    2406             </summary>
    2407             <param name="logEvent">the event to log</param>
    2408             <remarks>
    2409             <para>
    2410             This method should not normally be used to log.
    2411             The <see cref="T:log4net.ILog"/> interface should be used
    2412             for routine logging. This interface can be obtained
    2413             using the <see cref="M:log4net.LogManager.GetLogger(System.String)"/> method.
    2414             </para>
    2415             <para>
    2416             The <c>logEvent</c> is delivered to the appropriate logger and
    2417             that logger is then responsible for logging the event.
    2418             </para>
    2419             </remarks>
    2420         </member>
    2421         <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">
    2422             <summary>
    2423             Returns all the Appenders that are configured as an Array.
    2424             </summary>
    2425             <returns>All the Appenders</returns>
    2426             <remarks>
    2427             <para>
    2428             Returns all the Appenders that are configured as an Array.
    2429             </para>
    2430             </remarks>
    2431         </member>
    2432         <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">
    2433             <summary>
    2434             Adds an object renderer for a specific class.
    2435             </summary>
    2436             <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>
    2437             <param name="rendererInstance">The object renderer used to render the object.</param>
    2438             <remarks>
    2439             <para>
    2440             Adds an object renderer for a specific class.
    2441             </para>
    2442             </remarks>
    2443         </member>
    2444         <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">
    2445             <summary>
    2446             Notify the registered listeners that the repository is shutting down
    2447             </summary>
    2448             <param name="e">Empty EventArgs</param>
    2449             <remarks>
    2450             <para>
    2451             Notify any listeners that this repository is shutting down.
    2452             </para>
    2453             </remarks>
    2454         </member>
    2455         <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">
    2456             <summary>
    2457             Notify the registered listeners that the repository has had its configuration reset
    2458             </summary>
    2459             <param name="e">Empty EventArgs</param>
    2460             <remarks>
    2461             <para>
    2462             Notify any listeners that this repository's configuration has been reset.
    2463             </para>
    2464             </remarks>
    2465         </member>
    2466         <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">
    2467             <summary>
    2468             Notify the registered listeners that the repository has had its configuration changed
    2469             </summary>
    2470             <param name="e">Empty EventArgs</param>
    2471             <remarks>
    2472             <para>
    2473             Notify any listeners that this repository's configuration has changed.
    2474             </para>
    2475             </remarks>
    2476         </member>
    2477         <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">
    2478             <summary>
    2479             Raise a configuration changed event on this repository
    2480             </summary>
    2481             <param name="e">EventArgs.Empty</param>
    2482             <remarks>
    2483             <para>
    2484             Applications that programmatically change the configuration of the repository should
    2485             raise this event notification to notify listeners.
    2486             </para>
    2487             </remarks>
    2488         </member>
    2489         <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">
    2490             <summary>
    2491             The name of the repository
    2492             </summary>
    2493             <value>
    2494             The string name of the repository
    2495             </value>
    2496             <remarks>
    2497             <para>
    2498             The name of this repository. The name is
    2499             used to store and lookup the repositories
    2500             stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.
    2501             </para>
    2502             </remarks>
    2503         </member>
    2504         <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">
    2505             <summary>
    2506             The threshold for all events in this repository
    2507             </summary>
    2508             <value>
    2509             The threshold for all events in this repository
    2510             </value>
    2511             <remarks>
    2512             <para>
    2513             The threshold for all events in this repository
    2514             </para>
    2515             </remarks>
    2516         </member>
    2517         <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">
    2518             <summary>
    2519             RendererMap accesses the object renderer map for this repository.
    2520             </summary>
    2521             <value>
    2522             RendererMap accesses the object renderer map for this repository.
    2523             </value>
    2524             <remarks>
    2525             <para>
    2526             RendererMap accesses the object renderer map for this repository.
    2527             </para>
    2528             <para>
    2529             The RendererMap holds a mapping between types and
    2530             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.
    2531             </para>
    2532             </remarks>
    2533         </member>
    2534         <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">
    2535             <summary>
    2536             The plugin map for this repository.
    2537             </summary>
    2538             <value>
    2539             The plugin map for this repository.
    2540             </value>
    2541             <remarks>
    2542             <para>
    2543             The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances
    2544             that have been attached to this repository.
    2545             </para>
    2546             </remarks>
    2547         </member>
    2548         <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">
    2549             <summary>
    2550             Get the level map for the Repository.
    2551             </summary>
    2552             <remarks>
    2553             <para>
    2554             Get the level map for the Repository.
    2555             </para>
    2556             <para>
    2557             The level map defines the mappings between
    2558             level names and <see cref="T:log4net.Core.Level"/> objects in
    2559             this repository.
    2560             </para>
    2561             </remarks>
    2562         </member>
    2563         <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">
    2564             <summary>
    2565             Flag indicates if this repository has been configured.
    2566             </summary>
    2567             <value>
    2568             Flag indicates if this repository has been configured.
    2569             </value>
    2570             <remarks>
    2571             <para>
    2572             Flag indicates if this repository has been configured.
    2573             </para>
    2574             </remarks>
    2575         </member>
    2576         <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">
    2577             <summary>
    2578             Event to notify that the repository has been shutdown.
    2579             </summary>
    2580             <value>
    2581             Event to notify that the repository has been shutdown.
    2582             </value>
    2583             <remarks>
    2584             <para>
    2585             Event raised when the repository has been shutdown.
    2586             </para>
    2587             </remarks>
    2588         </member>
    2589         <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">
    2590             <summary>
    2591             Event to notify that the repository has had its configuration reset.
    2592             </summary>
    2593             <value>
    2594             Event to notify that the repository has had its configuration reset.
    2595             </value>
    2596             <remarks>
    2597             <para>
    2598             Event raised when the repository's configuration has been
    2599             reset to default.
    2600             </para>
    2601             </remarks>
    2602         </member>
    2603         <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">
    2604             <summary>
    2605             Event to notify that the repository has had its configuration changed.
    2606             </summary>
    2607             <value>
    2608             Event to notify that the repository has had its configuration changed.
    2609             </value>
    2610             <remarks>
    2611             <para>
    2612             Event raised when the repository's configuration has been changed.
    2613             </para>
    2614             </remarks>
    2615         </member>
    2616         <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">
    2617             <summary>
    2618             Repository specific properties
    2619             </summary>
    2620             <value>
    2621             Repository specific properties
    2622             </value>
    2623             <remarks>
    2624             These properties can be specified on a repository specific basis
    2625             </remarks>
    2626         </member>
    2627         <member name="T:log4net.Repository.IBasicRepositoryConfigurator">
    2628             <summary>
    2629             Basic Configurator interface for repositories
    2630             </summary>
    2631             <remarks>
    2632             <para>
    2633             Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>
    2634             with a default <see cref="T:log4net.Appender.IAppender"/>.
    2635             </para>
    2636             <para>
    2637             A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
    2638             configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.
    2639             </para>
    2640             </remarks>
    2641             <author>Nicko Cadell</author>
    2642             <author>Gert Driesen</author>
    2643         </member>
    2644         <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">
    2645             <summary>
    2646             Initialize the repository using the specified appender
    2647             </summary>
    2648             <param name="appender">the appender to use to log all logging events</param>
    2649             <remarks>
    2650             <para>
    2651             Configure the repository to route all logging events to the
    2652             specified appender.
    2653             </para>
    2654             </remarks>
    2655         </member>
    2656         <member name="T:log4net.Repository.IXmlRepositoryConfigurator">
    2657             <summary>
    2658             Configure repository using XML
    2659             </summary>
    2660             <remarks>
    2661             <para>
    2662             Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.
    2663             </para>
    2664             <para>
    2665             A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support
    2666             configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.
    2667             </para>
    2668             </remarks>
    2669             <author>Nicko Cadell</author>
    2670             <author>Gert Driesen</author>
    2671         </member>
    2672         <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">
    2673             <summary>
    2674             Initialize the repository using the specified config
    2675             </summary>
    2676             <param name="element">the element containing the root of the config</param>
    2677             <remarks>
    2678             <para>
    2679             The schema for the XML configuration data is defined by
    2680             the implementation.
    2681             </para>
    2682             </remarks>
    2683         </member>
    2684         <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">
    2685             <summary>
    2686             Default constructor
    2687             </summary>
    2688             <remarks>
    2689             <para>
    2690             Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
    2691             </para>
    2692             </remarks>
    2693         </member>
    2694         <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">
    2695             <summary>
    2696             Construct with properties
    2697             </summary>
    2698             <param name="properties">The properties to pass to this repository.</param>
    2699             <remarks>
    2700             <para>
    2701             Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.
    2702             </para>
    2703             </remarks>
    2704         </member>
    2705         <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">
    2706             <summary>
    2707             Construct with a logger factory
    2708             </summary>
    2709             <param name="loggerFactory">The factory to use to create new logger instances.</param>
    2710             <remarks>
    2711             <para>
    2712             Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with
    2713             the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
    2714             </para>
    2715             </remarks>
    2716         </member>
    2717         <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">
    2718             <summary>
    2719             Construct with properties and a logger factory
    2720             </summary>
    2721             <param name="properties">The properties to pass to this repository.</param>
    2722             <param name="loggerFactory">The factory to use to create new logger instances.</param>
    2723             <remarks>
    2724             <para>
    2725             Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with
    2726             the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.
    2727             </para>
    2728             </remarks>
    2729         </member>
    2730         <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">
    2731             <summary>
    2732             Test if a logger exists
    2733             </summary>
    2734             <param name="name">The name of the logger to lookup</param>
    2735             <returns>The Logger object with the name specified</returns>
    2736             <remarks>
    2737             <para>
    2738             Check if the named logger exists in the hierarchy. If so return
    2739             its reference, otherwise returns <c>null</c>.
    2740             </para>
    2741             </remarks>
    2742         </member>
    2743         <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">
    2744             <summary>
    2745             Returns all the currently defined loggers in the hierarchy as an Array
    2746             </summary>
    2747             <returns>All the defined loggers</returns>
    2748             <remarks>
    2749             <para>
    2750             Returns all the currently defined loggers in the hierarchy as an Array.
    2751             The root logger is <b>not</b> included in the returned
    2752             enumeration.
    2753             </para>
    2754             </remarks>
    2755         </member>
    2756         <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">
    2757             <summary>
    2758             Return a new logger instance named as the first parameter using
    2759             the default factory.
    2760             </summary>
    2761             <remarks>
    2762             <para>
    2763             Return a new logger instance named as the first parameter using
    2764             the default factory.
    2765             </para>
    2766             <para>
    2767             If a logger of that name already exists, then it will be
    2768             returned.  Otherwise, a new logger will be instantiated and
    2769             then linked with its existing ancestors as well as children.
    2770             </para>
    2771             </remarks>
    2772             <param name="name">The name of the logger to retrieve</param>
    2773             <returns>The logger object with the name specified</returns>
    2774         </member>
    2775         <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">
    2776             <summary>
    2777             Shutting down a hierarchy will <i>safely</i> close and remove
    2778             all appenders in all loggers including the root logger.
    2779             </summary>
    2780             <remarks>
    2781             <para>
    2782             Shutting down a hierarchy will <i>safely</i> close and remove
    2783             all appenders in all loggers including the root logger.
    2784             </para>
    2785             <para>
    2786             Some appenders need to be closed before the
    2787             application exists. Otherwise, pending logging events might be
    2788             lost.
    2789             </para>
    2790             <para>
    2791             The <c>Shutdown</c> method is careful to close nested
    2792             appenders before closing regular appenders. This is allows
    2793             configurations where a regular appender is attached to a logger
    2794             and again to a nested appender.
    2795             </para>
    2796             </remarks>
    2797         </member>
    2798         <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">
    2799             <summary>
    2800             Reset all values contained in this hierarchy instance to their default.
    2801             </summary>
    2802             <remarks>
    2803             <para>
    2804             Reset all values contained in this hierarchy instance to their
    2805             default.  This removes all appenders from all loggers, sets
    2806             the level of all non-root loggers to <c>null</c>,
    2807             sets their additivity flag to <c>true</c> and sets the level
    2808             of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,
    2809             message disabling is set its default "off" value.
    2810             </para>
    2811             <para>
    2812             Existing loggers are not removed. They are just reset.
    2813             </para>
    2814             <para>
    2815             This method should be used sparingly and with care as it will
    2816             block all logging until it is completed.
    2817             </para>
    2818             </remarks>
    2819         </member>
    2820         <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">
    2821             <summary>
    2822             Log the logEvent through this hierarchy.
    2823             </summary>
    2824             <param name="logEvent">the event to log</param>
    2825             <remarks>
    2826             <para>
    2827             This method should not normally be used to log.
    2828             The <see cref="T:log4net.ILog"/> interface should be used
    2829             for routine logging. This interface can be obtained
    2830             using the <see cref="M:log4net.LogManager.GetLogger(System.String)"/> method.
    2831             </para>
    2832             <para>
    2833             The <c>logEvent</c> is delivered to the appropriate logger and
    2834             that logger is then responsible for logging the event.
    2835             </para>
    2836             </remarks>
    2837         </member>
    2838         <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">
    2839             <summary>
    2840             Returns all the Appenders that are currently configured
    2841             </summary>
    2842             <returns>An array containing all the currently configured appenders</returns>
    2843             <remarks>
    2844             <para>
    2845             Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.
    2846             All the loggers are searched for appenders. The appenders may also be containers
    2847             for appenders and these are also searched for additional loggers.
    2848             </para>
    2849             <para>
    2850             The list returned is unordered but does not contain duplicates.
    2851             </para>
    2852             </remarks>
    2853         </member>
    2854         <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">
    2855             <summary>
    2856             Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.
    2857             The appender may also be a container.
    2858             </summary>
    2859             <param name="appenderList"></param>
    2860             <param name="appender"></param>
    2861         </member>
    2862         <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">
    2863             <summary>
    2864             Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container
    2865             </summary>
    2866             <param name="appenderList"></param>
    2867             <param name="container"></param>
    2868         </member>
    2869         <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">
    2870             <summary>
    2871             Initialize the log4net system using the specified appender
    2872             </summary>
    2873             <param name="appender">the appender to use to log all logging events</param>
    2874         </member>
    2875         <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender)">
    2876             <summary>
    2877             Initialize the log4net system using the specified appender
    2878             </summary>
    2879             <param name="appender">the appender to use to log all logging events</param>
    2880             <remarks>
    2881             <para>
    2882             This method provides the same functionality as the
    2883             <see cref="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)"/> method implemented
    2884             on this object, but it is protected and therefore can be called by subclasses.
    2885             </para>
    2886             </remarks>
    2887         </member>
    2888         <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">
    2889             <summary>
    2890             Initialize the log4net system using the specified config
    2891             </summary>
    2892             <param name="element">the element containing the root of the config</param>
    2893         </member>
    2894         <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">
    2895             <summary>
    2896             Initialize the log4net system using the specified config
    2897             </summary>
    2898             <param name="element">the element containing the root of the config</param>
    2899             <remarks>
    2900             <para>
    2901             This method provides the same functionality as the
    2902             <see cref="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)"/> method implemented
    2903             on this object, but it is protected and therefore can be called by subclasses.
    2904             </para>
    2905             </remarks>
    2906         </member>
    2907         <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">
    2908             <summary>
    2909             Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.
    2910             </summary>
    2911             <param name="level">The level to check against.</param>
    2912             <returns>
    2913             <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.
    2914             </returns>
    2915             <remarks>
    2916             <para>
    2917             If this hierarchy has not been configured then this method will
    2918             always return <c>true</c>.
    2919             </para>
    2920             <para>
    2921             This method will return <c>true</c> if this repository is
    2922             disabled for <c>level</c> object passed as parameter and
    2923             <c>false</c> otherwise.
    2924             </para>
    2925             <para>
    2926             See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.
    2927             </para>
    2928             </remarks>
    2929         </member>
    2930         <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">
    2931             <summary>
    2932             Clear all logger definitions from the internal hashtable
    2933             </summary>
    2934             <remarks>
    2935             <para>
    2936             This call will clear all logger definitions from the internal
    2937             hashtable. Invoking this method will irrevocably mess up the
    2938             logger hierarchy.
    2939             </para>
    2940             <para>
    2941             You should <b>really</b> know what you are doing before
    2942             invoking this method.
    2943             </para>
    2944             </remarks>
    2945         </member>
    2946         <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">
    2947             <summary>
    2948             Return a new logger instance named as the first parameter using
    2949             <paramref name="factory"/>.
    2950             </summary>
    2951             <param name="name">The name of the logger to retrieve</param>
    2952             <param name="factory">The factory that will make the new logger instance</param>
    2953             <returns>The logger object with the name specified</returns>
    2954             <remarks>
    2955             <para>
    2956             If a logger of that name already exists, then it will be
    2957             returned. Otherwise, a new logger will be instantiated by the
    2958             <paramref name="factory"/> parameter and linked with its existing
    2959             ancestors as well as children.
    2960             </para>
    2961             </remarks>
    2962         </member>
    2963         <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">
    2964             <summary>
    2965             Sends a logger creation event to all registered listeners
    2966             </summary>
    2967             <param name="logger">The newly created logger</param>
    2968             <remarks>
    2969             Raises the logger creation event.
    2970             </remarks>
    2971         </member>
    2972         <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">
    2973             <summary>
    2974             Updates all the parents of the specified logger
    2975             </summary>
    2976             <param name="log">The logger to update the parents for</param>
    2977             <remarks>
    2978             <para>
    2979             This method loops through all the <i>potential</i> parents of
    2980             <paramref name="log"/>. There 3 possible cases:
    2981             </para>
    2982             <list type="number">
    2983                 <item>
    2984                         <term>No entry for the potential parent of <paramref name="log"/> exists</term>
    2985                         <description>
    2986                         We create a ProvisionNode for this potential
    2987                         parent and insert <paramref name="log"/> in that provision node.
    2988                         </description>
    2989                 </item>
    2990                 <item>
    2991                         <term>The entry is of type Logger for the potential parent.</term>
    2992                         <description>
    2993                         The entry is <paramref name="log"/>'s nearest existing parent. We
    2994                         update <paramref name="log"/>'s parent field with this entry. We also break from
    2995                         he loop because updating our parent's parent is our parent's
    2996                         responsibility.
    2997                         </description>
    2998                 </item>
    2999                 <item>
    3000                         <term>The entry is of type ProvisionNode for this potential parent.</term>
    3001                         <description>
    3002                         We add <paramref name="log"/> to the list of children for this
    3003                         potential parent.
    3004                         </description>
    3005                 </item>
    3006             </list>
    3007             </remarks>
    3008         </member>
    3009         <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">
    3010             <summary>
    3011             Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.
    3012             </summary>
    3013             <param name="pn"></param>
    3014             <param name="log"></param>
    3015             <remarks>
    3016             <para>
    3017             We update the links for all the children that placed themselves
    3018             in the provision node 'pn'. The second argument 'log' is a
    3019             reference for the newly created Logger, parent of all the
    3020             children in 'pn'.
    3021             </para>
    3022             <para>
    3023             We loop on all the children 'c' in 'pn'.
    3024             </para>
    3025             <para>
    3026             If the child 'c' has been already linked to a child of
    3027             'log' then there is no need to update 'c'.
    3028             </para>
    3029             <para>
    3030             Otherwise, we set log's parent field to c's parent and set
    3031             c's parent field to log.
    3032             </para>
    3033             </remarks>
    3034         </member>
    3035         <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">
    3036             <summary>
    3037             Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
    3038             </summary>
    3039             <param name="levelEntry">the level values</param>
    3040             <remarks>
    3041             <para>
    3042             Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
    3043             </para>
    3044             <para>
    3045             Supports setting levels via the configuration file.
    3046             </para>
    3047             </remarks>
    3048         </member>
    3049         <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Repository.Hierarchy.Hierarchy.PropertyEntry)">
    3050             <summary>
    3051             Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument
    3052             </summary>
    3053             <param name="propertyEntry">the property value</param>
    3054             <remarks>
    3055             <para>
    3056             Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.
    3057             </para>
    3058             <para>
    3059             Supports setting property values via the configuration file.
    3060             </para>
    3061             </remarks>
    3062         </member>
    3063         <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">
    3064             <summary>
    3065             Event used to notify that a logger has been created.
    3066             </summary>
    3067             <remarks>
    3068             <para>
    3069             Event raised when a logger is created.
    3070             </para>
    3071             </remarks>
    3072         </member>
    3073         <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">
    3074             <summary>
    3075             Has no appender warning been emitted
    3076             </summary>
    3077             <remarks>
    3078             <para>
    3079             Flag to indicate if we have already issued a warning
    3080             about not having an appender warning.
    3081             </para>
    3082             </remarks>
    3083         </member>
    3084         <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">
    3085             <summary>
    3086             Get the root of this hierarchy
    3087             </summary>
    3088             <remarks>
    3089             <para>
    3090             Get the root of this hierarchy.
    3091             </para>
    3092             </remarks>
    3093         </member>
    3094         <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">
    3095             <summary>
    3096             Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.
    3097             </summary>
    3098             <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>
    3099             <remarks>
    3100             <para>
    3101             The logger factory is used to create logger instances.
    3102             </para>
    3103             </remarks>
    3104         </member>
    3105         <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">
    3106             <summary>
    3107             A class to hold the value, name and display name for a level
    3108             </summary>
    3109             <remarks>
    3110             <para>
    3111             A class to hold the value, name and display name for a level
    3112             </para>
    3113             </remarks>
    3114         </member>
    3115         <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">
    3116             <summary>
    3117             Override <c>Object.ToString</c> to return sensible debug info
    3118             </summary>
    3119             <returns>string info about this object</returns>
    3120         </member>
    3121         <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">
    3122             <summary>
    3123             Value of the level
    3124             </summary>
    3125             <remarks>
    3126             <para>
    3127             If the value is not set (defaults to -1) the value will be looked
    3128             up for the current level with the same name.
    3129             </para>
    3130             </remarks>
    3131         </member>
    3132         <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">
    3133             <summary>
    3134             Name of the level
    3135             </summary>
    3136             <value>
    3137             The name of the level
    3138             </value>
    3139             <remarks>
    3140             <para>
    3141             The name of the level.
    3142             </para>
    3143             </remarks>
    3144         </member>
    3145         <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">
    3146             <summary>
    3147             Display name for the level
    3148             </summary>
    3149             <value>
    3150             The display name of the level
    3151             </value>
    3152             <remarks>
    3153             <para>
    3154             The display name of the level.
    3155             </para>
    3156             </remarks>
    3157         </member>
    3158         <member name="T:log4net.Repository.Hierarchy.Hierarchy.PropertyEntry">
    3159             <summary>
    3160             A class to hold the key and data for a property set in the config file
    3161             </summary>
    3162             <remarks>
    3163             <para>
    3164             A class to hold the key and data for a property set in the config file
    3165             </para>
    3166             </remarks>
    3167         </member>
    3168         <member name="M:log4net.Repository.Hierarchy.Hierarchy.PropertyEntry.ToString">
    3169             <summary>
    3170             Override <c>Object.ToString</c> to return sensible debug info
    3171             </summary>
    3172             <returns>string info about this object</returns>
    3173         </member>
    3174         <member name="P:log4net.Repository.Hierarchy.Hierarchy.PropertyEntry.Key">
    3175             <summary>
    3176             Property Key
    3177             </summary>
    3178             <value>
    3179             Property Key
    3180             </value>
    3181             <remarks>
    3182             <para>
    3183             Property Key.
    3184             </para>
    3185             </remarks>
    3186         </member>
    3187         <member name="P:log4net.Repository.Hierarchy.Hierarchy.PropertyEntry.Value">
    3188             <summary>
    3189             Property Value
    3190             </summary>
    3191             <value>
    3192             Property Value
    3193             </value>
    3194             <remarks>
    3195             <para>
    3196             Property Value.
    3197             </para>
    3198             </remarks>
    3199         </member>
    3200         <member name="T:log4net.Layout.XmlLayoutBase">
    3201             <summary>
    3202             Layout that formats the log events as XML elements.
    3203             </summary>
    3204             <remarks>
    3205             <para>
    3206             This is an abstract class that must be subclassed by an implementation
    3207             to conform to a specific schema.
    3208             </para>
    3209             <para>
    3210             Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.
    3211             </para>
    3212             </remarks>
    3213             <author>Nicko Cadell</author>
    3214             <author>Gert Driesen</author>
    3215         </member>
    3216         <member name="T:log4net.Layout.LayoutSkeleton">
    3217             <summary>
    3218             Extend this abstract class to create your own log layout format.
    3219             </summary>
    3220             <remarks>
    3221             <para>
    3222             This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>
    3223             interface. Most layout objects should extend this class.
    3224             </para>
    3225             </remarks>
    3226             <remarks>
    3227             <note type="inheritinfo">
    3228             <para>
    3229             Subclasses must implement the <see cref="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)"/>
    3230             method.
    3231             </para>
    3232             <para>
    3233             Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default
    3234             constructor.
    3235             </para>
    3236             </note>
    3237             </remarks>
    3238             <author>Nicko Cadell</author>
    3239             <author>Gert Driesen</author>
    3240         </member>
    3241         <member name="T:log4net.Layout.ILayout">
    3242             <summary>
    3243             Interface implemented by layout objects
    3244             </summary>
    3245             <remarks>
    3246             <para>
    3247             An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>
    3248             as text. The <see cref="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)"/> method is called by an
    3249             appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.
    3250             </para>
    3251             <para>
    3252             The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>
    3253             text that is appender before any events and after all the events respectively.
    3254             </para>
    3255             </remarks>
    3256             <author>Nicko Cadell</author>
    3257             <author>Gert Driesen</author>
    3258         </member>
    3259         <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    3260             <summary>
    3261             Implement this method to create your own layout format.
    3262             </summary>
    3263             <param name="writer">The TextWriter to write the formatted event to</param>
    3264             <param name="loggingEvent">The event to format</param>
    3265             <remarks>
    3266             <para>
    3267             This method is called by an appender to format
    3268             the <paramref name="loggingEvent"/> as text and output to a writer.
    3269             </para>
    3270             <para>
    3271             If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the
    3272             event to be formatted as a <see cref="T:System.String"/> then the following
    3273             code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.
    3274             </para>
    3275             <code lang="C#">
    3276             StringWriter writer = new StringWriter();
    3277             Layout.Format(writer, loggingEvent);
    3278             string formattedEvent = writer.ToString();
    3279             </code>
    3280             </remarks>
    3281         </member>
    3282         <member name="P:log4net.Layout.ILayout.ContentType">
    3283             <summary>
    3284             The content type output by this layout.
    3285             </summary>
    3286             <value>The content type</value>
    3287             <remarks>
    3288             <para>
    3289             The content type output by this layout.
    3290             </para>
    3291             <para>
    3292             This is a MIME type e.g. <c>"text/plain"</c>.
    3293             </para>
    3294             </remarks>
    3295         </member>
    3296         <member name="P:log4net.Layout.ILayout.Header">
    3297             <summary>
    3298             The header for the layout format.
    3299             </summary>
    3300             <value>the layout header</value>
    3301             <remarks>
    3302             <para>
    3303             The Header text will be appended before any logging events
    3304             are formatted and appended.
    3305             </para>
    3306             </remarks>
    3307         </member>
    3308         <member name="P:log4net.Layout.ILayout.Footer">
    3309             <summary>
    3310             The footer for the layout format.
    3311             </summary>
    3312             <value>the layout footer</value>
    3313             <remarks>
    3314             <para>
    3315             The Footer text will be appended after all the logging events
    3316             have been formatted and appended.
    3317             </para>
    3318             </remarks>
    3319         </member>
    3320         <member name="P:log4net.Layout.ILayout.IgnoresException">
    3321             <summary>
    3322             Flag indicating if this layout handle exceptions
    3323             </summary>
    3324             <value><c>false</c> if this layout handles exceptions</value>
    3325             <remarks>
    3326             <para>
    3327             If this layout handles the exception object contained within
    3328             <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
    3329             <c>false</c>. Otherwise, if the layout ignores the exception
    3330             object, then the layout should return <c>true</c>.
    3331             </para>
    3332             </remarks>
    3333         </member>
    3334         <member name="F:log4net.Layout.LayoutSkeleton.m_header">
    3335             <summary>
    3336             The header text
    3337             </summary>
    3338             <remarks>
    3339             <para>
    3340             See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.
    3341             </para>
    3342             </remarks>
    3343         </member>
    3344         <member name="F:log4net.Layout.LayoutSkeleton.m_footer">
    3345             <summary>
    3346             The footer text
    3347             </summary>
    3348             <remarks>
    3349             <para>
    3350             See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.
    3351             </para>
    3352             </remarks>
    3353         </member>
    3354         <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">
    3355             <summary>
    3356             Flag indicating if this layout handles exceptions
    3357             </summary>
    3358             <remarks>
    3359             <para>
    3360             <c>false</c> if this layout handles exceptions
    3361             </para>
    3362             </remarks>
    3363         </member>
    3364         <member name="M:log4net.Layout.LayoutSkeleton.#ctor">
    3365             <summary>
    3366             Empty default constructor
    3367             </summary>
    3368             <remarks>
    3369             <para>
    3370             Empty default constructor
    3371             </para>
    3372             </remarks>
    3373         </member>
    3374         <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">
    3375             <summary>
    3376             Activate component options
    3377             </summary>
    3378             <remarks>
    3379             <para>
    3380             This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
    3381             activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must
    3382             be called on this object after the configuration properties have
    3383             been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this
    3384             object is in an undefined state and must not be used.
    3385             </para>
    3386             <para>
    3387             If any of the configuration properties are modified then
    3388             <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.
    3389             </para>
    3390             <para>
    3391             This method must be implemented by the subclass.
    3392             </para>
    3393             </remarks>
    3394         </member>
    3395         <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    3396             <summary>
    3397             Implement this method to create your own layout format.
    3398             </summary>
    3399             <param name="writer">The TextWriter to write the formatted event to</param>
    3400             <param name="loggingEvent">The event to format</param>
    3401             <remarks>
    3402             <para>
    3403             This method is called by an appender to format
    3404             the <paramref name="loggingEvent"/> as text.
    3405             </para>
    3406             </remarks>
    3407         </member>
    3408         <member name="P:log4net.Layout.LayoutSkeleton.ContentType">
    3409             <summary>
    3410             The content type output by this layout.
    3411             </summary>
    3412             <value>The content type is <c>"text/plain"</c></value>
    3413             <remarks>
    3414             <para>
    3415             The content type output by this layout.
    3416             </para>
    3417             <para>
    3418             This base class uses the value <c>"text/plain"</c>.
    3419             To change this value a subclass must override this
    3420             property.
    3421             </para>
    3422             </remarks>
    3423         </member>
    3424         <member name="P:log4net.Layout.LayoutSkeleton.Header">
    3425             <summary>
    3426             The header for the layout format.
    3427             </summary>
    3428             <value>the layout header</value>
    3429             <remarks>
    3430             <para>
    3431             The Header text will be appended before any logging events
    3432             are formatted and appended.
    3433             </para>
    3434             </remarks>
    3435         </member>
    3436         <member name="P:log4net.Layout.LayoutSkeleton.Footer">
    3437             <summary>
    3438             The footer for the layout format.
    3439             </summary>
    3440             <value>the layout footer</value>
    3441             <remarks>
    3442             <para>
    3443             The Footer text will be appended after all the logging events
    3444             have been formatted and appended.
    3445             </para>
    3446             </remarks>
    3447         </member>
    3448         <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">
    3449             <summary>
    3450             Flag indicating if this layout handles exceptions
    3451             </summary>
    3452             <value><c>false</c> if this layout handles exceptions</value>
    3453             <remarks>
    3454             <para>
    3455             If this layout handles the exception object contained within
    3456             <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return
    3457             <c>false</c>. Otherwise, if the layout ignores the exception
    3458             object, then the layout should return <c>true</c>.
    3459             </para>
    3460             <para>
    3461             Set this value to override a this default setting. The default
    3462             value is <c>true</c>, this layout does not handle the exception.
    3463             </para>
    3464             </remarks>
    3465         </member>
    3466         <member name="M:log4net.Layout.XmlLayoutBase.#ctor">
    3467             <summary>
    3468             Protected constructor to support subclasses
    3469             </summary>
    3470             <remarks>
    3471             <para>
    3472             Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class
    3473             with no location info.
    3474             </para>
    3475             </remarks>
    3476         </member>
    3477         <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">
    3478             <summary>
    3479             Protected constructor to support subclasses
    3480             </summary>
    3481             <remarks>
    3482             <para>
    3483             The <paramref name="locationInfo" /> parameter determines whether
    3484             location information will be output by the layout. If
    3485             <paramref name="locationInfo" /> is set to <c>true</c>, then the
    3486             file name and line number of the statement at the origin of the log
    3487             statement will be output.
    3488             </para>
    3489             <para>
    3490             If you are embedding this layout within an SMTPAppender
    3491             then make sure to set the <b>LocationInfo</b> option of that
    3492             appender as well.
    3493             </para>
    3494             </remarks>
    3495         </member>
    3496         <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">
    3497             <summary>
    3498             Initialize layout options
    3499             </summary>
    3500             <remarks>
    3501             <para>
    3502             This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
    3503             activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must
    3504             be called on this object after the configuration properties have
    3505             been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this
    3506             object is in an undefined state and must not be used.
    3507             </para>
    3508             <para>
    3509             If any of the configuration properties are modified then
    3510             <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.
    3511             </para>
    3512             </remarks>
    3513         </member>
    3514         <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    3515             <summary>
    3516             Produces a formatted string.
    3517             </summary>
    3518             <param name="loggingEvent">The event being logged.</param>
    3519             <param name="writer">The TextWriter to write the formatted event to</param>
    3520             <remarks>
    3521             <para>
    3522             Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.
    3523             </para>
    3524             <para>
    3525             This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the
    3526             <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed
    3527             to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the
    3528             <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.
    3529             </para>
    3530             </remarks>
    3531         </member>
    3532         <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">
    3533             <summary>
    3534             Does the actual writing of the XML.
    3535             </summary>
    3536             <param name="writer">The writer to use to output the event to.</param>
    3537             <param name="loggingEvent">The event to write.</param>
    3538             <remarks>
    3539             <para>
    3540             Subclasses should override this method to format
    3541             the <see cref="T:log4net.Core.LoggingEvent"/> as XML.
    3542             </para>
    3543             </remarks>
    3544         </member>
    3545         <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">
    3546             <summary>
    3547             Flag to indicate if location information should be included in
    3548             the XML events.
    3549             </summary>
    3550         </member>
    3551         <member name="F:log4net.Layout.XmlLayoutBase.m_protectCloseTextWriter">
    3552             <summary>
    3553             Writer adapter that ignores Close
    3554             </summary>
    3555         </member>
    3556         <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">
    3557             <summary>
    3558             The string to replace invalid chars with
    3559             </summary>
    3560         </member>
    3561         <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">
    3562             <summary>
    3563             Gets a value indicating whether to include location information in
    3564             the XML events.
    3565             </summary>
    3566             <value>
    3567             <c>true</c> if location information should be included in the XML
    3568             events; otherwise, <c>false</c>.
    3569             </value>
    3570             <remarks>
    3571             <para>
    3572             If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file
    3573             name and line number of the statement at the origin of the log
    3574             statement will be output.
    3575             </para>
    3576             <para>
    3577             If you are embedding this layout within an <c>SMTPAppender</c>
    3578             then make sure to set the <b>LocationInfo</b> option of that
    3579             appender as well.
    3580             </para>
    3581             </remarks>
    3582         </member>
    3583         <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">
    3584             <summary>
    3585             The string to replace characters that can not be expressed in XML with.
    3586             <remarks>
    3587             <para>
    3588             Not all characters may be expressed in XML. This property contains the
    3589             string to replace those that can not with. This defaults to a ?. Set it
    3590             to the empty string to simply remove offending characters. For more
    3591             details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets
    3592             Character replacement will occur in  the log message, the property names
    3593             and the property values.
    3594             </para>
    3595             </remarks>
    3596             </summary>
    3597         </member>
    3598         <member name="P:log4net.Layout.XmlLayoutBase.ContentType">
    3599             <summary>
    3600             Gets the content type output by this layout.
    3601             </summary>
    3602             <value>
    3603             As this is the XML layout, the value is always <c>"text/xml"</c>.
    3604             </value>
    3605             <remarks>
    3606             <para>
    3607             As this is the XML layout, the value is always <c>"text/xml"</c>.
    3608             </para>
    3609             </remarks>
    3610         </member>
    3611         <member name="T:log4net.Layout.SimpleLayout">
    3612             <summary>
    3613             A very simple layout
    3614             </summary>
    3615             <remarks>
    3616             <para>
    3617             SimpleLayout consists of the level of the log statement,
    3618             followed by " - " and then the log message itself. For example,
    3619             <code>
    3620             DEBUG - Hello world
    3621             </code>
    3622             </para>
    3623             </remarks>
    3624             <author>Nicko Cadell</author>
    3625             <author>Gert Driesen</author>
    3626         </member>
    3627         <member name="M:log4net.Layout.SimpleLayout.#ctor">
    3628             <summary>
    3629             Constructs a SimpleLayout
    3630             </summary>
    3631         </member>
    3632         <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">
    3633             <summary>
    3634             Initialize layout options
    3635             </summary>
    3636             <remarks>
    3637             <para>
    3638             This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
    3639             activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must
    3640             be called on this object after the configuration properties have
    3641             been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this
    3642             object is in an undefined state and must not be used.
    3643             </para>
    3644             <para>
    3645             If any of the configuration properties are modified then
    3646             <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.
    3647             </para>
    3648             </remarks>
    3649         </member>
    3650         <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    3651             <summary>
    3652             Produces a simple formatted output.
    3653             </summary>
    3654             <param name="loggingEvent">the event being logged</param>
    3655             <param name="writer">The TextWriter to write the formatted event to</param>
    3656             <remarks>
    3657             <para>
    3658             Formats the event as the level of the even,
    3659             followed by " - " and then the log message itself. The
    3660             output is terminated by a newline.
    3661             </para>
    3662             </remarks>
    3663         </member>
    3664         <member name="T:log4net.Layout.Pattern.MessagePatternConverter">
    3665             <summary>
    3666             Writes the event message to the output
    3667             </summary>
    3668             <remarks>
    3669             <para>
    3670             Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
    3671             to write out the event message.
    3672             </para>
    3673             </remarks>
    3674             <author>Nicko Cadell</author>
    3675         </member>
    3676         <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">
    3677             <summary>
    3678             Writes the event message to the output
    3679             </summary>
    3680             <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>
    3681             <param name="loggingEvent">the event being logged</param>
    3682             <remarks>
    3683             <para>
    3684             Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method
    3685             to write out the event message.
    3686             </para>
    3687             </remarks>
    3688         </member>
    3689         <member name="T:log4net.ILog">
    3690             <summary>
    3691             The ILog interface is use by application to log messages into
    3692             the log4net framework.
    3693             </summary>
    3694             <remarks>
    3695             <para>
    3696             Use the <see cref="T:log4net.LogManager"/> to obtain logger instances
    3697             that implement this interface. The <see cref="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)"/>
    3698             static method is used to get logger instances.
    3699             </para>
    3700             <para>
    3701             This class contains methods for logging at different levels and also
    3702             has properties for determining if those logging levels are
    3703             enabled in the current configuration.
    3704             </para>
    3705             <para>
    3706             This interface can be implemented in different ways. This documentation
    3707             specifies reasonable behavior that a caller can expect from the actual
    3708             implementation, however different implementations reserve the right to
    3709             do things differently.
    3710             </para>
    3711             </remarks>
    3712             <example>Simple example of logging messages
    3713             <code lang="C#">
    3714             ILog log = LogManager.GetLogger("application-log");
    3715            
    3716             log.Info("Application Start");
    3717             log.Debug("This is a debug message");
    3718            
    3719             if (log.IsDebugEnabled)
    3720             {
    3721                 log.Debug("This is another debug message");
    3722             }
    3723             </code>
    3724             </example>
    3725             <seealso cref="T:log4net.LogManager"/>
    3726             <seealso cref="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)"/>
    3727             <author>Nicko Cadell</author>
    3728             <author>Gert Driesen</author>
    3729         </member>
    3730         <member name="T:log4net.Core.ILoggerWrapper">
    3731             <summary>
    3732             Base interface for all wrappers
    3733             </summary>
    3734             <remarks>
    3735             <para>
    3736             Base interface for all wrappers.
    3737             </para>
    3738             <para>
    3739             All wrappers must implement this interface.
    3740             </para>
    3741             </remarks>
    3742             <author>Nicko Cadell</author>
    3743         </member>
    3744         <member name="P:log4net.Core.ILoggerWrapper.Logger">
    3745             <summary>
    3746             Get the implementation behind this wrapper object.
    3747             </summary>
    3748             <value>
    3749             The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.
    3750             </value>
    3751             <remarks>
    3752             <para>
    3753             The <see cref="T:log4net.Core.ILogger"/> object that in implementing this
    3754             object. The <c>Logger</c> object may not
    3755             be the same object as this object because of logger decorators.
    3756             This gets the actual underlying objects that is used to process
    3757             the log events.
    3758             </para>
    3759             </remarks>
    3760         </member>
    3761         <member name="M:log4net.ILog.Debug(System.Object)">
    3762             <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
    3763             <summary>
    3764             Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.
    3765             </summary>
    3766             <param name="message">The message object to log.</param>
    3767             <remarks>
    3768             <para>
    3769             This method first checks if this logger is <c>DEBUG</c>
    3770             enabled by comparing the level of this logger with the
    3771             <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is
    3772             <c>DEBUG</c> enabled, then it converts the message object
    3773             (passed as parameter) to a string by invoking the appropriate
    3774             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then
    3775             proceeds to call all the registered appenders in this logger
    3776             and also higher in the hierarchy depending on the value of
    3777             the additivity flag.
    3778             </para>
    3779             <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/>
    3780             to this method will print the name of the <see cref="T:System.Exception"/>
    3781             but no stack trace. To print a stack trace use the
    3782             <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/> form instead.
    3783             </para>
    3784             </remarks>
    3785             <seealso cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
    3786             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3787         </member>
    3788         <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">
    3789             <summary>
    3790             Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including
    3791             the stack trace of the <see cref="T:System.Exception"/> passed
    3792             as a parameter.
    3793             </summary>
    3794             <param name="message">The message object to log.</param>
    3795             <param name="exception">The exception to log, including its stack trace.</param>
    3796             <remarks>
    3797             <para>
    3798             See the <see cref="M:log4net.ILog.Debug(System.Object)"/> form for more detailed information.
    3799             </para>
    3800             </remarks>
    3801             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    3802             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3803         </member>
    3804         <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">
    3805             <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>
    3806             <summary>
    3807             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
    3808             </summary>
    3809             <param name="format">A String containing zero or more format items</param>
    3810             <param name="args">An Object array containing zero or more objects to format</param>
    3811             <remarks>
    3812             <para>
    3813             The message is formatted using the <c>String.Format</c> method. See
    3814             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3815             of the formatting.
    3816             </para>
    3817             <para>
    3818             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3819             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
    3820             methods instead.
    3821             </para>
    3822             </remarks>
    3823             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    3824             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3825         </member>
    3826         <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">
    3827             <summary>
    3828             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
    3829             </summary>
    3830             <param name="format">A String containing zero or more format items</param>
    3831             <param name="arg0">An Object to format</param>
    3832             <remarks>
    3833             <para>
    3834             The message is formatted using the <c>String.Format</c> method. See
    3835             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3836             of the formatting.
    3837             </para>
    3838             <para>
    3839             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3840             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
    3841             methods instead.
    3842             </para>
    3843             </remarks>
    3844             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    3845             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3846         </member>
    3847         <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">
    3848             <summary>
    3849             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
    3850             </summary>
    3851             <param name="format">A String containing zero or more format items</param>
    3852             <param name="arg0">An Object to format</param>
    3853             <param name="arg1">An Object to format</param>
    3854             <remarks>
    3855             <para>
    3856             The message is formatted using the <c>String.Format</c> method. See
    3857             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3858             of the formatting.
    3859             </para>
    3860             <para>
    3861             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3862             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
    3863             methods instead.
    3864             </para>
    3865             </remarks>
    3866             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    3867             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3868         </member>
    3869         <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">
    3870             <summary>
    3871             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
    3872             </summary>
    3873             <param name="format">A String containing zero or more format items</param>
    3874             <param name="arg0">An Object to format</param>
    3875             <param name="arg1">An Object to format</param>
    3876             <param name="arg2">An Object to format</param>
    3877             <remarks>
    3878             <para>
    3879             The message is formatted using the <c>String.Format</c> method. See
    3880             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3881             of the formatting.
    3882             </para>
    3883             <para>
    3884             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3885             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
    3886             methods instead.
    3887             </para>
    3888             </remarks>
    3889             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    3890             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3891         </member>
    3892         <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">
    3893             <summary>
    3894             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.
    3895             </summary>
    3896             <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
    3897             <param name="format">A String containing zero or more format items</param>
    3898             <param name="args">An Object array containing zero or more objects to format</param>
    3899             <remarks>
    3900             <para>
    3901             The message is formatted using the <c>String.Format</c> method. See
    3902             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3903             of the formatting.
    3904             </para>
    3905             <para>
    3906             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3907             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Debug(System.Object,System.Exception)"/>
    3908             methods instead.
    3909             </para>
    3910             </remarks>
    3911             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    3912             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    3913         </member>
    3914         <member name="M:log4net.ILog.Info(System.Object)">
    3915             <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
    3916             <summary>
    3917             Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.
    3918             </summary>
    3919             <remarks>
    3920             <para>
    3921             This method first checks if this logger is <c>INFO</c>
    3922             enabled by comparing the level of this logger with the
    3923             <see cref="F:log4net.Core.Level.Info"/> level. If this logger is
    3924             <c>INFO</c> enabled, then it converts the message object
    3925             (passed as parameter) to a string by invoking the appropriate
    3926             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then
    3927             proceeds to call all the registered appenders in this logger
    3928             and also higher in the hierarchy depending on the value of the
    3929             additivity flag.
    3930             </para>
    3931             <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/>
    3932             to this method will print the name of the <see cref="T:System.Exception"/>
    3933             but no stack trace. To print a stack trace use the
    3934             <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/> form instead.
    3935             </para>
    3936             </remarks>
    3937             <param name="message">The message object to log.</param>
    3938             <seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
    3939             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    3940         </member>
    3941         <member name="M:log4net.ILog.Info(System.Object,System.Exception)">
    3942             <summary>
    3943             Logs a message object with the <c>INFO</c> level including
    3944             the stack trace of the <see cref="T:System.Exception"/> passed
    3945             as a parameter.
    3946             </summary>
    3947             <param name="message">The message object to log.</param>
    3948             <param name="exception">The exception to log, including its stack trace.</param>
    3949             <remarks>
    3950             <para>
    3951             See the <see cref="M:log4net.ILog.Info(System.Object)"/> form for more detailed information.
    3952             </para>
    3953             </remarks>
    3954             <seealso cref="M:log4net.ILog.Info(System.Object)"/>
    3955             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    3956         </member>
    3957         <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">
    3958             <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>
    3959             <summary>
    3960             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
    3961             </summary>
    3962             <param name="format">A String containing zero or more format items</param>
    3963             <param name="args">An Object array containing zero or more objects to format</param>
    3964             <remarks>
    3965             <para>
    3966             The message is formatted using the <c>String.Format</c> method. See
    3967             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3968             of the formatting.
    3969             </para>
    3970             <para>
    3971             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3972             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object)"/>
    3973             methods instead.
    3974             </para>
    3975             </remarks>
    3976             <seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
    3977             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    3978         </member>
    3979         <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">
    3980             <summary>
    3981             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
    3982             </summary>
    3983             <param name="format">A String containing zero or more format items</param>
    3984             <param name="arg0">An Object to format</param>
    3985             <remarks>
    3986             <para>
    3987             The message is formatted using the <c>String.Format</c> method. See
    3988             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    3989             of the formatting.
    3990             </para>
    3991             <para>
    3992             This method does not take an <see cref="T:System.Exception"/> object to include in the
    3993             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
    3994             methods instead.
    3995             </para>
    3996             </remarks>
    3997             <seealso cref="M:log4net.ILog.Info(System.Object)"/>
    3998             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    3999         </member>
    4000         <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">
    4001             <summary>
    4002             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
    4003             </summary>
    4004             <param name="format">A String containing zero or more format items</param>
    4005             <param name="arg0">An Object to format</param>
    4006             <param name="arg1">An Object to format</param>
    4007             <remarks>
    4008             <para>
    4009             The message is formatted using the <c>String.Format</c> method. See
    4010             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4011             of the formatting.
    4012             </para>
    4013             <para>
    4014             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4015             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
    4016             methods instead.
    4017             </para>
    4018             </remarks>
    4019             <seealso cref="M:log4net.ILog.Info(System.Object)"/>
    4020             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    4021         </member>
    4022         <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">
    4023             <summary>
    4024             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
    4025             </summary>
    4026             <param name="format">A String containing zero or more format items</param>
    4027             <param name="arg0">An Object to format</param>
    4028             <param name="arg1">An Object to format</param>
    4029             <param name="arg2">An Object to format</param>
    4030             <remarks>
    4031             <para>
    4032             The message is formatted using the <c>String.Format</c> method. See
    4033             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4034             of the formatting.
    4035             </para>
    4036             <para>
    4037             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4038             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
    4039             methods instead.
    4040             </para>
    4041             </remarks>
    4042             <seealso cref="M:log4net.ILog.Info(System.Object)"/>
    4043             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    4044         </member>
    4045         <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">
    4046             <summary>
    4047             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.
    4048             </summary>
    4049             <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
    4050             <param name="format">A String containing zero or more format items</param>
    4051             <param name="args">An Object array containing zero or more objects to format</param>
    4052             <remarks>
    4053             <para>
    4054             The message is formatted using the <c>String.Format</c> method. See
    4055             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4056             of the formatting.
    4057             </para>
    4058             <para>
    4059             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4060             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Info(System.Object)"/>
    4061             methods instead.
    4062             </para>
    4063             </remarks>
    4064             <seealso cref="M:log4net.ILog.Info(System.Object,System.Exception)"/>
    4065             <seealso cref="P:log4net.ILog.IsInfoEnabled"/>
    4066         </member>
    4067         <member name="M:log4net.ILog.Warn(System.Object)">
    4068             <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
    4069             <summary>
    4070             Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.
    4071             </summary>
    4072             <remarks>
    4073             <para>
    4074             This method first checks if this logger is <c>WARN</c>
    4075             enabled by comparing the level of this logger with the
    4076             <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is
    4077             <c>WARN</c> enabled, then it converts the message object
    4078             (passed as parameter) to a string by invoking the appropriate
    4079             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then
    4080             proceeds to call all the registered appenders in this logger
    4081             and also higher in the hierarchy depending on the value of the
    4082             additivity flag.
    4083             </para>
    4084             <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/>
    4085             to this method will print the name of the <see cref="T:System.Exception"/>
    4086             but no stack trace. To print a stack trace use the
    4087             <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/> form instead.
    4088             </para>
    4089             </remarks>
    4090             <param name="message">The message object to log.</param>
    4091             <seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
    4092             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4093         </member>
    4094         <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">
    4095             <summary>
    4096             Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including
    4097             the stack trace of the <see cref="T:System.Exception"/> passed
    4098             as a parameter.
    4099             </summary>
    4100             <param name="message">The message object to log.</param>
    4101             <param name="exception">The exception to log, including its stack trace.</param>
    4102             <remarks>
    4103             <para>
    4104             See the <see cref="M:log4net.ILog.Warn(System.Object)"/> form for more detailed information.
    4105             </para>
    4106             </remarks>
    4107             <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
    4108             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4109         </member>
    4110         <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">
    4111             <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>
    4112             <summary>
    4113             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
    4114             </summary>
    4115             <param name="format">A String containing zero or more format items</param>
    4116             <param name="args">An Object array containing zero or more objects to format</param>
    4117             <remarks>
    4118             <para>
    4119             The message is formatted using the <c>String.Format</c> method. See
    4120             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4121             of the formatting.
    4122             </para>
    4123             <para>
    4124             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4125             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object)"/>
    4126             methods instead.
    4127             </para>
    4128             </remarks>
    4129             <seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
    4130             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4131         </member>
    4132         <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">
    4133             <summary>
    4134             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
    4135             </summary>
    4136             <param name="format">A String containing zero or more format items</param>
    4137             <param name="arg0">An Object to format</param>
    4138             <remarks>
    4139             <para>
    4140             The message is formatted using the <c>String.Format</c> method. See
    4141             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4142             of the formatting.
    4143             </para>
    4144             <para>
    4145             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4146             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
    4147             methods instead.
    4148             </para>
    4149             </remarks>
    4150             <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
    4151             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4152         </member>
    4153         <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">
    4154             <summary>
    4155             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
    4156             </summary>
    4157             <param name="format">A String containing zero or more format items</param>
    4158             <param name="arg0">An Object to format</param>
    4159             <param name="arg1">An Object to format</param>
    4160             <remarks>
    4161             <para>
    4162             The message is formatted using the <c>String.Format</c> method. See
    4163             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4164             of the formatting.
    4165             </para>
    4166             <para>
    4167             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4168             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
    4169             methods instead.
    4170             </para>
    4171             </remarks>
    4172             <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
    4173             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4174         </member>
    4175         <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">
    4176             <summary>
    4177             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
    4178             </summary>
    4179             <param name="format">A String containing zero or more format items</param>
    4180             <param name="arg0">An Object to format</param>
    4181             <param name="arg1">An Object to format</param>
    4182             <param name="arg2">An Object to format</param>
    4183             <remarks>
    4184             <para>
    4185             The message is formatted using the <c>String.Format</c> method. See
    4186             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4187             of the formatting.
    4188             </para>
    4189             <para>
    4190             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4191             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
    4192             methods instead.
    4193             </para>
    4194             </remarks>
    4195             <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
    4196             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4197         </member>
    4198         <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">
    4199             <summary>
    4200             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.
    4201             </summary>
    4202             <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
    4203             <param name="format">A String containing zero or more format items</param>
    4204             <param name="args">An Object array containing zero or more objects to format</param>
    4205             <remarks>
    4206             <para>
    4207             The message is formatted using the <c>String.Format</c> method. See
    4208             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4209             of the formatting.
    4210             </para>
    4211             <para>
    4212             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4213             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Warn(System.Object)"/>
    4214             methods instead.
    4215             </para>
    4216             </remarks>
    4217             <seealso cref="M:log4net.ILog.Warn(System.Object,System.Exception)"/>
    4218             <seealso cref="P:log4net.ILog.IsWarnEnabled"/>
    4219         </member>
    4220         <member name="M:log4net.ILog.Error(System.Object)">
    4221             <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
    4222             <summary>
    4223             Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.
    4224             </summary>
    4225             <param name="message">The message object to log.</param>
    4226             <remarks>
    4227             <para>
    4228             This method first checks if this logger is <c>ERROR</c>
    4229             enabled by comparing the level of this logger with the
    4230             <see cref="F:log4net.Core.Level.Error"/> level. If this logger is
    4231             <c>ERROR</c> enabled, then it converts the message object
    4232             (passed as parameter) to a string by invoking the appropriate
    4233             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then
    4234             proceeds to call all the registered appenders in this logger
    4235             and also higher in the hierarchy depending on the value of the
    4236             additivity flag.
    4237             </para>
    4238             <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/>
    4239             to this method will print the name of the <see cref="T:System.Exception"/>
    4240             but no stack trace. To print a stack trace use the
    4241             <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/> form instead.
    4242             </para>
    4243             </remarks>
    4244             <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
    4245             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4246         </member>
    4247         <member name="M:log4net.ILog.Error(System.Object,System.Exception)">
    4248             <summary>
    4249             Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including
    4250             the stack trace of the <see cref="T:System.Exception"/> passed
    4251             as a parameter.
    4252             </summary>
    4253             <param name="message">The message object to log.</param>
    4254             <param name="exception">The exception to log, including its stack trace.</param>
    4255             <remarks>
    4256             <para>
    4257             See the <see cref="M:log4net.ILog.Error(System.Object)"/> form for more detailed information.
    4258             </para>
    4259             </remarks>
    4260             <seealso cref="M:log4net.ILog.Error(System.Object)"/>
    4261             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4262         </member>
    4263         <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">
    4264             <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>
    4265             <summary>
    4266             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
    4267             </summary>
    4268             <param name="format">A String containing zero or more format items</param>
    4269             <param name="args">An Object array containing zero or more objects to format</param>
    4270             <remarks>
    4271             <para>
    4272             The message is formatted using the <c>String.Format</c> method. See
    4273             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4274             of the formatting.
    4275             </para>
    4276             <para>
    4277             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4278             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object)"/>
    4279             methods instead.
    4280             </para>
    4281             </remarks>
    4282             <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
    4283             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4284         </member>
    4285         <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">
    4286             <summary>
    4287             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
    4288             </summary>
    4289             <param name="format">A String containing zero or more format items</param>
    4290             <param name="arg0">An Object to format</param>
    4291             <remarks>
    4292             <para>
    4293             The message is formatted using the <c>String.Format</c> method. See
    4294             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4295             of the formatting.
    4296             </para>
    4297             <para>
    4298             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4299             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
    4300             methods instead.
    4301             </para>
    4302             </remarks>
    4303             <seealso cref="M:log4net.ILog.Error(System.Object)"/>
    4304             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4305         </member>
    4306         <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">
    4307             <summary>
    4308             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
    4309             </summary>
    4310             <param name="format">A String containing zero or more format items</param>
    4311             <param name="arg0">An Object to format</param>
    4312             <param name="arg1">An Object to format</param>
    4313             <remarks>
    4314             <para>
    4315             The message is formatted using the <c>String.Format</c> method. See
    4316             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4317             of the formatting.
    4318             </para>
    4319             <para>
    4320             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4321             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
    4322             methods instead.
    4323             </para>
    4324             </remarks>
    4325             <seealso cref="M:log4net.ILog.Error(System.Object)"/>
    4326             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4327         </member>
    4328         <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">
    4329             <summary>
    4330             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
    4331             </summary>
    4332             <param name="format">A String containing zero or more format items</param>
    4333             <param name="arg0">An Object to format</param>
    4334             <param name="arg1">An Object to format</param>
    4335             <param name="arg2">An Object to format</param>
    4336             <remarks>
    4337             <para>
    4338             The message is formatted using the <c>String.Format</c> method. See
    4339             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4340             of the formatting.
    4341             </para>
    4342             <para>
    4343             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4344             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
    4345             methods instead.
    4346             </para>
    4347             </remarks>
    4348             <seealso cref="M:log4net.ILog.Error(System.Object)"/>
    4349             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4350         </member>
    4351         <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">
    4352             <summary>
    4353             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.
    4354             </summary>
    4355             <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
    4356             <param name="format">A String containing zero or more format items</param>
    4357             <param name="args">An Object array containing zero or more objects to format</param>
    4358             <remarks>
    4359             <para>
    4360             The message is formatted using the <c>String.Format</c> method. See
    4361             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4362             of the formatting.
    4363             </para>
    4364             <para>
    4365             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4366             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Error(System.Object)"/>
    4367             methods instead.
    4368             </para>
    4369             </remarks>
    4370             <seealso cref="M:log4net.ILog.Error(System.Object,System.Exception)"/>
    4371             <seealso cref="P:log4net.ILog.IsErrorEnabled"/>
    4372         </member>
    4373         <member name="M:log4net.ILog.Fatal(System.Object)">
    4374             <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
    4375             <summary>
    4376             Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4377             </summary>
    4378             <remarks>
    4379             <para>
    4380             This method first checks if this logger is <c>FATAL</c>
    4381             enabled by comparing the level of this logger with the
    4382             <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is
    4383             <c>FATAL</c> enabled, then it converts the message object
    4384             (passed as parameter) to a string by invoking the appropriate
    4385             <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then
    4386             proceeds to call all the registered appenders in this logger
    4387             and also higher in the hierarchy depending on the value of the
    4388             additivity flag.
    4389             </para>
    4390             <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/>
    4391             to this method will print the name of the <see cref="T:System.Exception"/>
    4392             but no stack trace. To print a stack trace use the
    4393             <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/> form instead.
    4394             </para>
    4395             </remarks>
    4396             <param name="message">The message object to log.</param>
    4397             <seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
    4398             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4399         </member>
    4400         <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">
    4401             <summary>
    4402             Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including
    4403             the stack trace of the <see cref="T:System.Exception"/> passed
    4404             as a parameter.
    4405             </summary>
    4406             <param name="message">The message object to log.</param>
    4407             <param name="exception">The exception to log, including its stack trace.</param>
    4408             <remarks>
    4409             <para>
    4410             See the <see cref="M:log4net.ILog.Fatal(System.Object)"/> form for more detailed information.
    4411             </para>
    4412             </remarks>
    4413             <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
    4414             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4415         </member>
    4416         <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">
    4417             <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>
    4418             <summary>
    4419             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4420             </summary>
    4421             <param name="format">A String containing zero or more format items</param>
    4422             <param name="args">An Object array containing zero or more objects to format</param>
    4423             <remarks>
    4424             <para>
    4425             The message is formatted using the <c>String.Format</c> method. See
    4426             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4427             of the formatting.
    4428             </para>
    4429             <para>
    4430             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4431             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object)"/>
    4432             methods instead.
    4433             </para>
    4434             </remarks>
    4435             <seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
    4436             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4437         </member>
    4438         <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">
    4439             <summary>
    4440             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4441             </summary>
    4442             <param name="format">A String containing zero or more format items</param>
    4443             <param name="arg0">An Object to format</param>
    4444             <remarks>
    4445             <para>
    4446             The message is formatted using the <c>String.Format</c> method. See
    4447             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4448             of the formatting.
    4449             </para>
    4450             <para>
    4451             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4452             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
    4453             methods instead.
    4454             </para>
    4455             </remarks>
    4456             <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
    4457             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4458         </member>
    4459         <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">
    4460             <summary>
    4461             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4462             </summary>
    4463             <param name="format">A String containing zero or more format items</param>
    4464             <param name="arg0">An Object to format</param>
    4465             <param name="arg1">An Object to format</param>
    4466             <remarks>
    4467             <para>
    4468             The message is formatted using the <c>String.Format</c> method. See
    4469             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4470             of the formatting.
    4471             </para>
    4472             <para>
    4473             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4474             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
    4475             methods instead.
    4476             </para>
    4477             </remarks>
    4478             <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
    4479             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4480         </member>
    4481         <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">
    4482             <summary>
    4483             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4484             </summary>
    4485             <param name="format">A String containing zero or more format items</param>
    4486             <param name="arg0">An Object to format</param>
    4487             <param name="arg1">An Object to format</param>
    4488             <param name="arg2">An Object to format</param>
    4489             <remarks>
    4490             <para>
    4491             The message is formatted using the <c>String.Format</c> method. See
    4492             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4493             of the formatting.
    4494             </para>
    4495             <para>
    4496             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4497             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
    4498             methods instead.
    4499             </para>
    4500             </remarks>
    4501             <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
    4502             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4503         </member>
    4504         <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">
    4505             <summary>
    4506             Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4507             </summary>
    4508             <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>
    4509             <param name="format">A String containing zero or more format items</param>
    4510             <param name="args">An Object array containing zero or more objects to format</param>
    4511             <remarks>
    4512             <para>
    4513             The message is formatted using the <c>String.Format</c> method. See
    4514             <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior
    4515             of the formatting.
    4516             </para>
    4517             <para>
    4518             This method does not take an <see cref="T:System.Exception"/> object to include in the
    4519             log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.ILog.Fatal(System.Object)"/>
    4520             methods instead.
    4521             </para>
    4522             </remarks>
    4523             <seealso cref="M:log4net.ILog.Fatal(System.Object,System.Exception)"/>
    4524             <seealso cref="P:log4net.ILog.IsFatalEnabled"/>
    4525         </member>
    4526         <member name="P:log4net.ILog.IsDebugEnabled">
    4527             <summary>
    4528             Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.
    4529             </summary>
    4530             <value>
    4531             <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.
    4532             </value>
    4533             <remarks>
    4534             <para>
    4535             This function is intended to lessen the computational cost of
    4536             disabled log debug statements.
    4537             </para>
    4538             <para> For some ILog interface <c>log</c>, when you write:</para>
    4539             <code lang="C#">
    4540             log.Debug("This is entry number: " + i );
    4541             </code>
    4542             <para>
    4543             You incur the cost constructing the message, string construction and concatenation in
    4544             this case, regardless of whether the message is logged or not.
    4545             </para>
    4546             <para>
    4547             If you are worried about speed (who isn't), then you should write:
    4548             </para>
    4549             <code lang="C#">
    4550             if (log.IsDebugEnabled)
    4551             {
    4552                 log.Debug("This is entry number: " + i );
    4553             }
    4554             </code>
    4555             <para>
    4556             This way you will not incur the cost of parameter
    4557             construction if debugging is disabled for <c>log</c>. On
    4558             the other hand, if the <c>log</c> is debug enabled, you
    4559             will incur the cost of evaluating whether the logger is debug
    4560             enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in
    4561             the <see cref="M:log4net.ILog.Debug(System.Object)"/>.  This is an insignificant overhead
    4562             since evaluating a logger takes about 1% of the time it
    4563             takes to actually log. This is the preferred style of logging.
    4564             </para>
    4565             <para>Alternatively if your logger is available statically then the is debug
    4566             enabled state can be stored in a static variable like this:
    4567             </para>
    4568             <code lang="C#">
    4569             private static readonly bool isDebugEnabled = log.IsDebugEnabled;
    4570             </code>
    4571             <para>
    4572             Then when you come to log you can write:
    4573             </para>
    4574             <code lang="C#">
    4575             if (isDebugEnabled)
    4576             {
    4577                 log.Debug("This is entry number: " + i );
    4578             }
    4579             </code>
    4580             <para>
    4581             This way the debug enabled state is only queried once
    4582             when the class is loaded. Using a <c>private static readonly</c>
    4583             variable is the most efficient because it is a run time constant
    4584             and can be heavily optimized by the JIT compiler.
    4585             </para>
    4586             <para>
    4587             Of course if you use a static readonly variable to
    4588             hold the enabled state of the logger then you cannot
    4589             change the enabled state at runtime to vary the logging
    4590             that is produced. You have to decide if you need absolute
    4591             speed or runtime flexibility.
    4592             </para>
    4593             </remarks>
    4594             <seealso cref="M:log4net.ILog.Debug(System.Object)"/>
    4595             <seealso cref="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])"/>
    4596         </member>
    4597         <member name="P:log4net.ILog.IsInfoEnabled">
    4598             <summary>
    4599             Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.
    4600             </summary>
    4601             <value>
    4602             <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.
    4603             </value>
    4604             <remarks>
    4605             For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
    4606             </remarks>
    4607             <seealso cref="M:log4net.ILog.Info(System.Object)"/>
    4608             <seealso cref="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])"/>
    4609             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    4610         </member>
    4611         <member name="P:log4net.ILog.IsWarnEnabled">
    4612             <summary>
    4613             Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.
    4614             </summary>
    4615             <value>
    4616             <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.
    4617             </value>
    4618             <remarks>
    4619             For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
    4620             </remarks>
    4621             <seealso cref="M:log4net.ILog.Warn(System.Object)"/>
    4622             <seealso cref="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])"/>
    4623             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    4624         </member>
    4625         <member name="P:log4net.ILog.IsErrorEnabled">
    4626             <summary>
    4627             Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.
    4628             </summary>
    4629             <value>
    4630             <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.
    4631             </value>
    4632             <remarks>
    4633             For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
    4634             </remarks>
    4635             <seealso cref="M:log4net.ILog.Error(System.Object)"/>
    4636             <seealso cref="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])"/>
    4637             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    4638         </member>
    4639         <member name="P:log4net.ILog.IsFatalEnabled">
    4640             <summary>
    4641             Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.
    4642             </summary>
    4643             <value>
    4644             <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.
    4645             </value>
    4646             <remarks>
    4647             For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.
    4648             </remarks>
    4649             <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>
    4650             <seealso cref="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])"/>
    4651             <seealso cref="P:log4net.ILog.IsDebugEnabled"/>
    4652         </member>
    4653         <member name="T:log4net.Filter.DenyAllFilter">
    4654             <summary>
    4655             This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>.
    4656             </summary>
    4657             <remarks>
    4658             <para>
    4659             You can add this filter to the end of a filter chain to
    4660             switch from the default "accept all unless instructed otherwise"
    4661             filtering behavior to a "deny all unless instructed otherwise"
    4662             behavior.
    4663             </para>
    4664             </remarks>
    4665             <author>Nicko Cadell</author>
    4666             <author>Gert Driesen</author>
    4667         </member>
    4668         <member name="T:log4net.Filter.FilterSkeleton">
    4669             <summary>
    4670             Subclass this type to implement customized logging event filtering
    4671             </summary>
    4672             <remarks>
    4673             <para>
    4674             Users should extend this class to implement customized logging
    4675             event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and
    4676             <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
    4677             appenders, have built-in filtering rules. It is suggested that you
    4678             first use and understand the built-in rules before rushing to write
    4679             your own custom filters.
    4680             </para>
    4681             <para>
    4682             This abstract class assumes and also imposes that filters be
    4683             organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>
    4684             method of each filter is called sequentially, in the order of their
    4685             addition to the chain.
    4686             </para>
    4687             <para>
    4688             The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one
    4689             of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>,
    4690             <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
    4691             </para>
    4692             <para>
    4693             If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped
    4694             immediately without consulting with the remaining filters.
    4695             </para>
    4696             <para>
    4697             If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
    4698             in the chain is consulted. If there are no more filters in the
    4699             chain, then the log event is logged. Thus, in the presence of no
    4700             filters, the default behavior is to log all logging events.
    4701             </para>
    4702             <para>
    4703             If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
    4704             event is logged without consulting the remaining filters.
    4705             </para>
    4706             <para>
    4707             The philosophy of log4net filters is largely inspired from the
    4708             Linux ipchains.
    4709             </para>
    4710             </remarks>
    4711             <author>Nicko Cadell</author>
    4712             <author>Gert Driesen</author>
    4713         </member>
    4714         <member name="T:log4net.Filter.IFilter">
    4715             <summary>
    4716             Implement this interface to provide customized logging event filtering
    4717             </summary>
    4718             <remarks>
    4719             <para>
    4720             Users should implement this interface to implement customized logging
    4721             event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and
    4722             <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard
    4723             appenders, have built-in filtering rules. It is suggested that you
    4724             first use and understand the built-in rules before rushing to write
    4725             your own custom filters.
    4726             </para>
    4727             <para>
    4728             This abstract class assumes and also imposes that filters be
    4729             organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>
    4730             method of each filter is called sequentially, in the order of their
    4731             addition to the chain.
    4732             </para>
    4733             <para>
    4734             The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one
    4735             of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>,
    4736             <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.
    4737             </para>
    4738             <para>
    4739             If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped
    4740             immediately without consulting with the remaining filters.
    4741             </para>
    4742             <para>
    4743             If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter
    4744             in the chain is consulted. If there are no more filters in the
    4745             chain, then the log event is logged. Thus, in the presence of no
    4746             filters, the default behavior is to log all logging events.
    4747             </para>
    4748             <para>
    4749             If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log
    4750             event is logged without consulting the remaining filters.
    4751             </para>
    4752             <para>
    4753             The philosophy of log4net filters is largely inspired from the
    4754             Linux ipchains.
    4755             </para>
    4756             </remarks>
    4757             <author>Nicko Cadell</author>
    4758             <author>Gert Driesen</author>
    4759         </member>
    4760         <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">
    4761             <summary>
    4762             Decide if the logging event should be logged through an appender.
    4763             </summary>
    4764             <param name="loggingEvent">The LoggingEvent to decide upon</param>
    4765             <returns>The decision of the filter</returns>
    4766             <remarks>
    4767             <para>
    4768             If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
    4769             dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
    4770             filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
    4771             the event will be logged without consulting with other filters in
    4772             the chain.
    4773             </para>
    4774             </remarks>
    4775         </member>
    4776         <member name="P:log4net.Filter.IFilter.Next">
    4777             <summary>
    4778             Property to get and set the next filter
    4779             </summary>
    4780             <value>
    4781             The next filter in the chain
    4782             </value>
    4783             <remarks>
    4784             <para>
    4785             Filters are typically composed into chains. This property allows the next filter in
    4786             the chain to be accessed.
    4787             </para>
    4788             </remarks>
    4789         </member>
    4790         <member name="F:log4net.Filter.FilterSkeleton.m_next">
    4791             <summary>
    4792             Points to the next filter in the filter chain.
    4793             </summary>
    4794             <remarks>
    4795             <para>
    4796             See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.
    4797             </para>
    4798             </remarks>
    4799         </member>
    4800         <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">
    4801             <summary>
    4802             Initialize the filter with the options set
    4803             </summary>
    4804             <remarks>
    4805             <para>
    4806             This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
    4807             activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must
    4808             be called on this object after the configuration properties have
    4809             been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this
    4810             object is in an undefined state and must not be used.
    4811             </para>
    4812             <para>
    4813             If any of the configuration properties are modified then
    4814             <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.
    4815             </para>
    4816             <para>
    4817             Typically filter's options become active immediately on set,
    4818             however this method must still be called.
    4819             </para>
    4820             </remarks>
    4821         </member>
    4822         <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">
    4823             <summary>
    4824             Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.
    4825             </summary>
    4826             <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>
    4827             <returns>The decision of the filter</returns>
    4828             <remarks>
    4829             <para>
    4830             If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be
    4831             dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next
    4832             filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then
    4833             the event will be logged without consulting with other filters in
    4834             the chain.
    4835             </para>
    4836             <para>
    4837             This method is marked <c>abstract</c> and must be implemented
    4838             in a subclass.
    4839             </para>
    4840             </remarks>
    4841         </member>
    4842         <member name="P:log4net.Filter.FilterSkeleton.Next">
    4843             <summary>
    4844             Property to get and set the next filter
    4845             </summary>
    4846             <value>
    4847             The next filter in the chain
    4848             </value>
    4849             <remarks>
    4850             <para>
    4851             Filters are typically composed into chains. This property allows the next filter in
    4852             the chain to be accessed.
    4853             </para>
    4854             </remarks>
    4855         </member>
    4856         <member name="M:log4net.Filter.DenyAllFilter.#ctor">
    4857             <summary>
    4858             Default constructor
    4859             </summary>
    4860         </member>
    4861         <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">
    4862             <summary>
    4863             Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>
    4864             </summary>
    4865             <param name="loggingEvent">the LoggingEvent to filter</param>
    4866             <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>
    4867             <remarks>
    4868             <para>
    4869             Ignores the event being logged and just returns
    4870             <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter
    4871             chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter
    4872             should only be used as the last filter in the chain
    4873             as any further filters will be ignored!
    4874             </para>
    4875             </remarks>
    4876         </member>
    4877         <member name="T:log4net.Core.ITriggeringEventEvaluator">
    4878             <summary>
    4879             Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action
    4880             </summary>
    4881             <remarks>
    4882             <para>
    4883             Implementations of this interface allow certain appenders to decide
    4884             when to perform an appender specific action.
    4885             </para>
    4886             <para>
    4887             The action or behavior triggered is defined by the implementation.
    4888             </para>
    4889             </remarks>
    4890             <author>Nicko Cadell</author>
    4891         </member>
    4892         <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">
    4893             <summary>
    4894             Test if this event triggers the action
    4895             </summary>
    4896             <param name="loggingEvent">The event to check</param>
    4897             <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>
    4898             <remarks>
    4899             <para>
    4900             Return <c>true</c> if this event triggers the action
    4901             </para>
    4902             </remarks>
    4903         </member>
    4904         <member name="T:log4net.Config.SecurityContextProviderAttribute">
    4905             <summary>
    4906             Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.
    4907             </summary>
    4908             <remarks>
    4909             <para>
    4910             This attribute may only be used at the assembly scope and can only
    4911             be used once per assembly.
    4912             </para>
    4913             <para>
    4914             Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>
    4915             without calling one of the <see cref="M:log4net.Config.XmlConfigurator.Configure"/>
    4916             methods.
    4917             </para>
    4918             </remarks>
    4919             <author>Nicko Cadell</author>
    4920         </member>
    4921         <member name="T:log4net.Config.ConfiguratorAttribute">
    4922             <summary>
    4923             Base class for all log4net configuration attributes.
    4924             </summary>
    4925             <remarks>
    4926             This is an abstract class that must be extended by
    4927             specific configurators. This attribute allows the
    4928             configurator to be parameterized by an assembly level
    4929             attribute.
    4930             </remarks>
    4931             <author>Nicko Cadell</author>
    4932             <author>Gert Driesen</author>
    4933         </member>
    4934         <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">
    4935             <summary>
    4936             Constructor used by subclasses.
    4937             </summary>
    4938             <param name="priority">the ordering priority for this configurator</param>
    4939             <remarks>
    4940             <para>
    4941             The <paramref name="priority"/> is used to order the configurator
    4942             attributes before they are invoked. Higher priority configurators are executed
    4943             before lower priority ones.
    4944             </para>
    4945             </remarks>
    4946         </member>
    4947         <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
    4948             <summary>
    4949             Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.
    4950             </summary>
    4951             <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
    4952             <param name="targetRepository">The repository to configure.</param>
    4953             <remarks>
    4954             <para>
    4955             Abstract method implemented by a subclass. When this method is called
    4956             the subclass should configure the <paramref name="targetRepository"/>.
    4957             </para>
    4958             </remarks>
    4959         </member>
    4960         <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">
    4961             <summary>
    4962             Compare this instance to another ConfiguratorAttribute
    4963             </summary>
    4964             <param name="obj">the object to compare to</param>
    4965             <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>
    4966             <remarks>
    4967             <para>
    4968             Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.
    4969             Sorts by priority in descending order. Objects with the same priority are
    4970             randomly ordered.
    4971             </para>
    4972             </remarks>
    4973         </member>
    4974         <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">
    4975             <summary>
    4976             Construct provider attribute with type specified
    4977             </summary>
    4978             <param name="providerType">the type of the provider to use</param>
    4979             <remarks>
    4980             <para>
    4981             The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
    4982             class.
    4983             </para>
    4984             </remarks>
    4985         </member>
    4986         <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">
    4987             <summary>
    4988             Configures the SecurityContextProvider
    4989             </summary>
    4990             <param name="sourceAssembly">The assembly that this attribute was defined on.</param>
    4991             <param name="targetRepository">The repository to configure.</param>
    4992             <remarks>
    4993             <para>
    4994             Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.
    4995             Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.
    4996             </para>
    4997             </remarks>
    4998         </member>
    4999         <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">
    5000             <summary>
    5001             Gets or sets the type of the provider to use.
    5002             </summary>
    5003             <value>
    5004             the type of the provider to use.
    5005             </value>
    5006             <remarks>
    5007             <para>
    5008             The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>
    5009             class.
    5010             </para>
    5011             </remarks>
    5012         </member>
    5013         <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">
    5014             <summary>
    5015             Class to register for the log4net section of the configuration file
    5016             </summary>
    5017             <remarks>
    5018             The log4net section of the configuration file needs to have a section
    5019             handler registered. This is the section handler used. It simply returns
    5020             the XML element that is the root of the section.
    5021             </remarks>
    5022             <example>
    5023             Example of registering the log4net section handler :
    5024             <code lang="XML" escaped="true">
    5025             <configuration>
    5026                 <configSections>
    5027                         <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
    5028                 </configSections>
    5029                 <log4net>
    5030                         log4net configuration XML goes here
    5031                 </log4net>
    5032             </configuration>
    5033             </code>
    5034             </example>
    5035             <author>Nicko Cadell</author>
    5036             <author>Gert Driesen</author>
    5037         </member>
    5038         <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">
    5039             <summary>
    5040             Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.
    5041             </summary>
    5042             <remarks>
    5043             <para>
    5044             Default constructor.
    5045             </para>
    5046             </remarks>
    5047         </member>
    5048         <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">
    5049             <summary>
    5050             Parses the configuration section.
    5051             </summary>
    5052             <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
    5053             <param name="configContext">The configuration context when called from the ASP.NET configuration system. Otherwise, this parameter is reserved and is a null reference.</param>
    5054             <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>
    5055             <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>
    5056             <remarks>
    5057             <para>
    5058             Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,
    5059             </para>
    5060             </remarks>
    5061         </member>
    5062         <member name="T:log4net.Appender.ForwardingAppender">
    5063             <summary>
    5064             This appender forwards logging events to attached appenders.
    5065             </summary>
    5066             <remarks>
    5067             <para>
    5068             The forwarding appender can be used to specify different thresholds
    5069             and filters for the same appender at different locations within the hierarchy.
    5070             </para>
    5071             </remarks>
    5072             <author>Nicko Cadell</author>
    5073             <author>Gert Driesen</author>
    5074         </member>
    5075         <member name="T:log4net.Core.IAppenderAttachable">
    5076             <summary>
    5077             Interface for attaching appenders to objects.
    5078             </summary>
    5079             <remarks>
    5080             <para>
    5081             Interface for attaching, removing and retrieving appenders.
    5082             </para>
    5083             </remarks>
    5084             <author>Nicko Cadell</author>
    5085             <author>Gert Driesen</author>
    5086         </member>
    5087         <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">
    5088             <summary>
    5089             Attaches an appender.
    5090             </summary>
    5091             <param name="appender">The appender to add.</param>
    5092             <remarks>
    5093             <para>
    5094             Add the specified appender. The implementation may
    5095             choose to allow or deny duplicate appenders.
    5096             </para>
    5097             </remarks>
    5098         </member>
    5099         <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">
    5100             <summary>
    5101             Gets an attached appender with the specified name.
    5102             </summary>
    5103             <param name="name">The name of the appender to get.</param>
    5104             <returns>
    5105             The appender with the name specified, or <c>null</c> if no appender with the
    5106             specified name is found.
    5107             </returns>
    5108             <remarks>
    5109             <para>
    5110             Returns an attached appender with the <paramref name="name"/> specified.
    5111             If no appender with the specified name is found <c>null</c> will be
    5112             returned.
    5113             </para>
    5114             </remarks>
    5115         </member>
    5116         <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">
    5117             <summary>
    5118             Removes all attached appenders.
    5119             </summary>
    5120             <remarks>
    5121             <para>
    5122             Removes and closes all attached appenders
    5123             </para>
    5124             </remarks>
    5125         </member>
    5126         <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">
    5127             <summary>
    5128             Removes the specified appender from the list of attached appenders.
    5129             </summary>
    5130             <param name="appender">The appender to remove.</param>
    5131             <returns>The appender removed from the list</returns>
    5132             <remarks>
    5133             <para>
    5134             The appender removed is not closed.
    5135             If you are discarding the appender you must call
    5136             <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
    5137             </para>
    5138             </remarks>
    5139         </member>
    5140         <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">
    5141             <summary>
    5142             Removes the appender with the specified name from the list of appenders.
    5143             </summary>
    5144             <param name="name">The name of the appender to remove.</param>
    5145             <returns>The appender removed from the list</returns>
    5146             <remarks>
    5147             <para>
    5148             The appender removed is not closed.
    5149             If you are discarding the appender you must call
    5150             <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
    5151             </para>
    5152             </remarks>
    5153         </member>
    5154         <member name="P:log4net.Core.IAppenderAttachable.Appenders">
    5155             <summary>
    5156             Gets all attached appenders.
    5157             </summary>
    5158             <value>
    5159             A collection of attached appenders.
    5160             </value>
    5161             <remarks>
    5162             <para>
    5163             Gets a collection of attached appenders.
    5164             If there are no attached appenders the
    5165             implementation should return an empty
    5166             collection rather than <c>null</c>.
    5167             </para>
    5168             </remarks>
    5169         </member>
    5170         <member name="M:log4net.Appender.ForwardingAppender.#ctor">
    5171             <summary>
    5172             Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.
    5173             </summary>
    5174             <remarks>
    5175             <para>
    5176             Default constructor.
    5177             </para>
    5178             </remarks>
    5179         </member>
    5180         <member name="M:log4net.Appender.ForwardingAppender.OnClose">
    5181             <summary>
    5182             Closes the appender and releases resources.
    5183             </summary>
    5184             <remarks>
    5185             <para>
    5186             Releases any resources allocated within the appender such as file handles,
    5187             network connections, etc.
    5188             </para>
    5189             <para>
    5190             It is a programming error to append to a closed appender.
    5191             </para>
    5192             </remarks>
    5193         </member>
    5194         <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">
    5195             <summary>
    5196             Forward the logging event to the attached appenders
    5197             </summary>
    5198             <param name="loggingEvent">The event to log.</param>
    5199             <remarks>
    5200             <para>
    5201             Delivers the logging event to all the attached appenders.
    5202             </para>
    5203             </remarks>
    5204         </member>
    5205         <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">
    5206             <summary>
    5207             Forward the logging events to the attached appenders
    5208             </summary>
    5209             <param name="loggingEvents">The array of events to log.</param>
    5210             <remarks>
    5211             <para>
    5212             Delivers the logging events to all the attached appenders.
    5213             </para>
    5214             </remarks>
    5215         </member>
    5216         <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">
    5217             <summary>
    5218             Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this
    5219             instance.
    5220             </summary>
    5221             <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>
    5222             <remarks>
    5223             <para>
    5224             If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of
    5225             appenders, then it won't be added again.
    5226             </para>
    5227             </remarks>
    5228         </member>
    5229         <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">
    5230             <summary>
    5231             Looks for the appender with the specified name.
    5232             </summary>
    5233             <param name="name">The name of the appender to lookup.</param>
    5234             <returns>
    5235             The appender with the specified name, or <c>null</c>.
    5236             </returns>
    5237             <remarks>
    5238             <para>
    5239             Get the named appender attached to this appender.
    5240             </para>
    5241             </remarks>
    5242         </member>
    5243         <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">
    5244             <summary>
    5245             Removes all previously added appenders from this appender.
    5246             </summary>
    5247             <remarks>
    5248             <para>
    5249             This is useful when re-reading configuration information.
    5250             </para>
    5251             </remarks>
    5252         </member>
    5253         <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">
    5254             <summary>
    5255             Removes the specified appender from the list of appenders.
    5256             </summary>
    5257             <param name="appender">The appender to remove.</param>
    5258             <returns>The appender removed from the list</returns>
    5259             <remarks>
    5260             The appender removed is not closed.
    5261             If you are discarding the appender you must call
    5262             <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
    5263             </remarks>
    5264         </member>
    5265         <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">
    5266             <summary>
    5267             Removes the appender with the specified name from the list of appenders.
    5268             </summary>
    5269             <param name="name">The name of the appender to remove.</param>
    5270             <returns>The appender removed from the list</returns>
    5271             <remarks>
    5272             The appender removed is not closed.
    5273             If you are discarding the appender you must call
    5274             <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.
    5275             </remarks>
    5276         </member>
    5277         <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">
    5278             <summary>
    5279             Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface
    5280             </summary>
    5281         </member>
    5282         <member name="P:log4net.Appender.ForwardingAppender.Appenders">
    5283             <summary>
    5284             Gets the appenders contained in this appender as an
    5285             <see cref="T:System.Collections.ICollection"/>.
    5286             </summary>
    5287             <remarks>
    5288             If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/>
    5289             is returned.
    5290             </remarks>
    5291             <returns>
    5292             A collection of the appenders in this appender.
    5293             </returns>
    5294         </member>
    5295         <member name="T:log4net.Util.ThreadContextProperties">
    5296             <summary>
    5297             Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>
    5298             </summary>
    5299             <remarks>
    5300             <para>
    5301             Class implements a collection of properties that is specific to each thread.
    5302             The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.
    5303             </para>
    5304             </remarks>
    5305             <author>Nicko Cadell</author>
    5306         </member>
    5307         <member name="T:log4net.Util.ContextPropertiesBase">
    5308             <summary>
    5309             Base class for Context Properties implementations
    5310             </summary>
    5311             <remarks>
    5312             <para>
    5313             This class defines a basic property get set accessor
    5314             </para>
    5315             </remarks>
    5316             <author>Nicko Cadell</author>
    5317         </member>
    5318         <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">
    5319             <summary>
    5320             Gets or sets the value of a property
    5321             </summary>
    5322             <value>
    5323             The value for the property with the specified key
    5324             </value>
    5325             <remarks>
    5326             <para>
    5327             Gets or sets the value of a property
    5328             </para>
    5329             </remarks>
    5330         </member>
    5331         <member name="F:log4net.Util.ThreadContextProperties.s_threadLocalSlot">
    5332             <summary>
    5333             The thread local data slot to use to store a PropertiesDictionary.
    5334             </summary>
    5335         </member>
    5336         <member name="M:log4net.Util.ThreadContextProperties.#ctor">
    5337             <summary>
    5338             Internal constructor
    5339             </summary>
    5340             <remarks>
    5341             <para>
    5342             Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.
    5343             </para>
    5344             </remarks>
    5345         </member>
    5346         <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">
    5347             <summary>
    5348</