log4netでTrotiNetのログを出力できるようにする

diff --git a/KancolleSniffer/App.config b/KancolleSniffer/App.config
index e743be0..be110a5 100644 (file)
--- a/KancolleSniffer/App.config
+++ b/KancolleSniffer/App.config
@@ -1,6 +1,23 @@
 <?xml version="1.0" encoding="utf-8"?>\r
 <configuration>\r
-    <startup> \r
+  <configSections>\r
+    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net"/>\r
+  </configSections>\r
+  <log4net>\r
+    <appender name="LogFileAppender" type="log4net.Appender.FileAppender">\r
+      <param name="File" value="network.log"/>\r
+      <param name="AppendToFile" value="true"/>\r
+      <layout type="log4net.Layout.PatternLayout">\r
+        <param name="ConversionPattern" value="%d [%t] %-5p %c - %m%n"/>\r
+      </layout>\r
+    </appender>\r
+    <root>\r
+      <level value="ALL"/>\r
+      <appender-ref ref="LogFileAppender"/>\r
+    </root>\r
+  </log4net>\r
+\r
+  <startup> \r
         \r
     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/></startup>\r
 </configuration>\r

diff --git a/Libraries/log4net/LICENSE b/Libraries/log4net/LICENSE
new file mode 100644 (file)
index 0000000..261eeb9
--- /dev/null
+++ b/Libraries/log4net/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

diff --git a/Libraries/log4net/NOTICE b/Libraries/log4net/NOTICE
new file mode 100644 (file)
index 0000000..29deee3
--- /dev/null
+++ b/Libraries/log4net/NOTICE
@@ -0,0 +1,5 @@
+   Apache log4net
+   Copyright 2004-2013 The Apache Software Foundation
+
+   This product includes software developed at
+   The Apache Software Foundation (http://www.apache.org/).

diff --git a/Libraries/log4net/log4net-1.2.13-src.zip b/Libraries/log4net/log4net-1.2.13-src.zip
new file mode 100644 (file)
index 0000000..77f6db7
Binary files /dev/null and b/Libraries/log4net/log4net-1.2.13-src.zip differ

diff --git a/Libraries/log4net/log4net.dll b/Libraries/log4net/log4net.dll
new file mode 100644 (file)
index 0000000..47cd9ad
Binary files /dev/null and b/Libraries/log4net/log4net.dll differ

diff --git a/Libraries/log4net/log4net.xml b/Libraries/log4net/log4net.xml
new file mode 100644 (file)
index 0000000..2584cd8
--- /dev/null
+++ b/Libraries/log4net/log4net.xml
@@ -0,0 +1,31814 @@
+<?xml version="1.0"?>\r
+<doc>\r
+    <assembly>\r
+        <name>log4net</name>\r
+    </assembly>\r
+    <members>\r
+        <member name="T:log4net.Appender.AdoNetAppender">\r
+            <summary>\r
+            Appender that logs to a database.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a\r
+            database. The appender can be configured to specify the connection \r
+            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. \r
+            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>\r
+            property. For more information on database connection strings for\r
+            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.\r
+            </para>\r
+            <para>\r
+            Records are written into the database either using a prepared\r
+            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property\r
+            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement\r
+            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored\r
+            procedure.\r
+            </para>\r
+            <para>\r
+            The prepared statement text or the name of the stored procedure\r
+            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.\r
+            </para>\r
+            <para>\r
+            The prepared statement or stored procedure can take a number\r
+            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>\r
+            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the\r
+            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>\r
+            type may be subclassed if required to provide database specific\r
+            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies\r
+            the parameter name, database type, size, and how the value should\r
+            be generated using a <see cref="T:log4net.Layout.ILayout"/>.\r
+            </para>\r
+            </remarks>\r
+            <example>\r
+            An example of a SQL Server table that could be logged to:\r
+            <code lang="SQL">\r
+            CREATE TABLE [dbo].[Log] ( \r
+              [ID] [int] IDENTITY (1, 1) NOT NULL ,\r
+              [Date] [datetime] NOT NULL ,\r
+              [Thread] [varchar] (255) NOT NULL ,\r
+              [Level] [varchar] (20) NOT NULL ,\r
+              [Logger] [varchar] (255) NOT NULL ,\r
+              [Message] [varchar] (4000) NOT NULL \r
+            ) ON [PRIMARY]\r
+            </code>\r
+            </example>\r
+            <example>\r
+            An example configuration to log to the above table:\r
+            <code lang="XML" escaped="true">\r
+            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">\r
+              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>\r
+              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>\r
+              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>\r
+              <parameter>\r
+                <parameterName value="@log_date"/>\r
+                <dbType value="DateTime"/>\r
+                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>\r
+              </parameter>\r
+              <parameter>\r
+                <parameterName value="@thread"/>\r
+                <dbType value="String"/>\r
+                <size value="255"/>\r
+                <layout type="log4net.Layout.PatternLayout" value="%thread"/>\r
+              </parameter>\r
+              <parameter>\r
+                <parameterName value="@log_level"/>\r
+                <dbType value="String"/>\r
+                <size value="50"/>\r
+                <layout type="log4net.Layout.PatternLayout" value="%level"/>\r
+              </parameter>\r
+              <parameter>\r
+                <parameterName value="@logger"/>\r
+                <dbType value="String"/>\r
+                <size value="255"/>\r
+                <layout type="log4net.Layout.PatternLayout" value="%logger"/>\r
+              </parameter>\r
+              <parameter>\r
+                <parameterName value="@message"/>\r
+                <dbType value="String"/>\r
+                <size value="4000"/>\r
+                <layout type="log4net.Layout.PatternLayout" value="%message"/>\r
+              </parameter>\r
+            </appender>\r
+            </code>\r
+            </example>\r
+            <author>Julian Biddle</author>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Lance Nehring</author>\r
+        </member>\r
+        <member name="T:log4net.Appender.BufferingAppenderSkeleton">\r
+            <summary>\r
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that \r
+            buffers events in a fixed size buffer.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This base class should be used by appenders that need to buffer a \r
+            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> \r
+            buffers events and then submits the entire contents of the buffer to \r
+            the underlying database in one go.\r
+            </para>\r
+            <para>\r
+            Subclasses should override the <see cref="M:SendBuffer(LoggingEvent[])"/>\r
+            method to deliver the buffered events.\r
+            </para>\r
+            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic \r
+            buffer of events. The size of the buffer is set using \r
+            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.\r
+            </para>\r
+            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect \r
+            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> \r
+            triggers, then the current buffer is sent immediately \r
+            (see <see cref="M:SendBuffer(LoggingEvent[])"/>). Otherwise the event \r
+            is stored in the buffer. For example, an evaluator can be used to \r
+            deliver the events immediately when an ERROR event arrives.\r
+            </para>\r
+            <para>\r
+            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. \r
+            By default the appender is NOT lossy. When the buffer is full all \r
+            the buffered events are sent with <see cref="M:SendBuffer(LoggingEvent[])"/>.\r
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the \r
+            buffer will not be sent when it is full, and new events arriving \r
+            in the appender will overwrite the oldest event in the buffer. \r
+            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>\r
+            triggers. This can be useful behavior when you need to know about \r
+            ERROR events but not about events with a lower level, configure an \r
+            evaluator that will trigger when an ERROR event arrives, the whole \r
+            buffer will be sent which gives a history of events leading up to\r
+            the ERROR event.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Appender.AppenderSkeleton">\r
+            <summary>\r
+            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class provides the code for common functionality, such \r
+            as support for threshold filtering and support for general filters.\r
+            </para>\r
+            <para>\r
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore\r
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method\r
+            be called after the appenders properties have been configured.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Appender.IAppender">\r
+            <summary>\r
+            Implement this interface for your own strategies for printing log statements.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>\r
+            class which provides a default implementation of this interface.\r
+            </para>\r
+            <para>\r
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore\r
+            they would require that the <see cref="M:IOptionHandler.ActivateOptions()"/> method\r
+            be called after the appenders properties have been configured.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.IAppender.Close">\r
+            <summary>\r
+            Closes the appender and releases resources.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Releases any resources allocated within the appender such as file handles, \r
+            network connections, etc.\r
+            </para>\r
+            <para>\r
+            It is a programming error to append to a closed appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Log the logging event in Appender specific way.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log</param>\r
+            <remarks>\r
+            <para>\r
+            This method is called to log a message into this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.IAppender.Name">\r
+            <summary>\r
+            Gets or sets the name of this appender.\r
+            </summary>\r
+            <value>The name of the appender.</value>\r
+            <remarks>\r
+            <para>The name uniquely identifies the appender.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.IBulkAppender">\r
+            <summary>\r
+            Interface for appenders that support bulk logging.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to\r
+            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders\r
+            should only implement this interface if they can bulk log efficiently.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Log the array of logging events in Appender specific way.\r
+            </summary>\r
+            <param name="loggingEvents">The events to log</param>\r
+            <remarks>\r
+            <para>\r
+            This method is called to log an array of events into this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.IOptionHandler">\r
+            <summary>\r
+            Interface used to delay activate a configured object.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This allows an object to defer activation of its options until all\r
+            options have been set. This is required for components which have\r
+            related options that remain ambiguous until all are set.\r
+            </para>\r
+            <para>\r
+            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method \r
+            must be called by the container after its all the configured properties have been set \r
+            and before the component can be used.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">\r
+            <summary>\r
+            Activate the options that were previously set with calls to properties.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This allows an object to defer activation of its options until all\r
+            options have been set. This is required for components which have\r
+            related options that remain ambiguous until all are set.\r
+            </para>\r
+            <para>\r
+            If a component implements this interface then this method must be called\r
+            after its properties have been set before the component can be used.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">\r
+            <summary>\r
+            Initial buffer size\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">\r
+            <summary>\r
+            Maximum buffer size before it is recycled\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>Empty default constructor</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">\r
+            <summary>\r
+            Finalizes this appender by calling the implementation's \r
+            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If this appender has not been closed then the <c>Finalize</c> method\r
+            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.Close">\r
+            <summary>\r
+            Closes the appender and release resources.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Release any resources allocated within the appender such as file handles, \r
+            network connections, etc.\r
+            </para>\r
+            <para>\r
+            It is a programming error to append to a closed appender.\r
+            </para>\r
+            <para>\r
+            This method cannot be overridden by subclasses. This method \r
+            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>\r
+            method which must be overridden in the subclass.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Performs threshold checks and invokes filters before \r
+            delegating actual logging to the subclasses specific \r
+            <see cref="M:Append(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method cannot be overridden by derived classes. A\r
+            derived class should override the <see cref="M:Append(LoggingEvent)"/> method\r
+            which is called by this method.\r
+            </para>\r
+            <para>\r
+            The implementation of this method is as follows:\r
+            </para>\r
+            <para>\r
+            <list type="bullet">\r
+               <item>\r
+                       <description>\r
+                       Checks that the severity of the <paramref name="loggingEvent"/>\r
+                       is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this\r
+                       appender.</description>\r
+               </item>\r
+               <item>\r
+                       <description>\r
+                       Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the \r
+                       <paramref name="loggingEvent"/>.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <description>\r
+                       Calls <see cref="M:PreAppendCheck()"/> and checks that \r
+                       it returns <c>true</c>.</description>\r
+               </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            If all of the above steps succeed then the <paramref name="loggingEvent"/>\r
+            will be passed to the abstract <see cref="M:Append(LoggingEvent)"/> method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Performs threshold checks and invokes filters before \r
+            delegating actual logging to the subclasses specific \r
+            <see cref="M:Append(LoggingEvent[])"/> method.\r
+            </summary>\r
+            <param name="loggingEvents">The array of events to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method cannot be overridden by derived classes. A\r
+            derived class should override the <see cref="M:Append(LoggingEvent[])"/> method\r
+            which is called by this method.\r
+            </para>\r
+            <para>\r
+            The implementation of this method is as follows:\r
+            </para>\r
+            <para>\r
+            <list type="bullet">\r
+               <item>\r
+                       <description>\r
+                       Checks that the severity of the <paramref name="loggingEvents"/>\r
+                       is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this\r
+                       appender.</description>\r
+               </item>\r
+               <item>\r
+                       <description>\r
+                       Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the \r
+                       <paramref name="loggingEvents"/>.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <description>\r
+                       Calls <see cref="M:PreAppendCheck()"/> and checks that \r
+                       it returns <c>true</c>.</description>\r
+               </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            If all of the above steps succeed then the <paramref name="loggingEvents"/>\r
+            will be passed to the <see cref="M:Append(LoggingEvent[])"/> method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Test if the logging event should we output by this appender\r
+            </summary>\r
+            <param name="loggingEvent">the event to test</param>\r
+            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>\r
+            <remarks>\r
+            <para>\r
+            This method checks the logging event against the threshold level set\r
+            on this appender and also against the filters specified on this\r
+            appender.\r
+            </para>\r
+            <para>\r
+            The implementation of this method is as follows:\r
+            </para>\r
+            <para>\r
+            <list type="bullet">\r
+               <item>\r
+                       <description>\r
+                       Checks that the severity of the <paramref name="loggingEvent"/>\r
+                       is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this\r
+                       appender.</description>\r
+               </item>\r
+               <item>\r
+                       <description>\r
+                       Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the \r
+                       <paramref name="loggingEvent"/>.\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">\r
+            <summary>\r
+            Adds a filter to the end of the filter chain.\r
+            </summary>\r
+            <param name="filter">the filter to add to this appender</param>\r
+            <remarks>\r
+            <para>\r
+            The Filters are organized in a linked list.\r
+            </para>\r
+            <para>\r
+            Setting this property causes the new filter to be pushed onto the \r
+            back of the filter chain.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">\r
+            <summary>\r
+            Clears the filter list for this appender.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clears the filter list for this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">\r
+            <summary>\r
+            Checks if the message level is below this appender's threshold.\r
+            </summary>\r
+            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>\r
+            <remarks>\r
+            <para>\r
+            If there is no threshold set, then the return value is always <c>true</c>.\r
+            </para>\r
+            </remarks>\r
+            <returns>\r
+            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> \r
+            requirements of this appender.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">\r
+            <summary>\r
+            Is called when the appender is closed. Derived classes should override \r
+            this method if resources need to be released.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Releases any resources allocated within the appender such as file handles, \r
+            network connections, etc.\r
+            </para>\r
+            <para>\r
+            It is a programming error to append to a closed appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method \r
+            to perform actual logging.\r
+            </summary>\r
+            <param name="loggingEvent">The event to append.</param>\r
+            <remarks>\r
+            <para>\r
+            A subclass must implement this method to perform\r
+            logging of the <paramref name="loggingEvent"/>.\r
+            </para>\r
+            <para>This method will be called by <see cref="M:DoAppend(LoggingEvent)"/>\r
+            if all the conditions listed for that method are met.\r
+            </para>\r
+            <para>\r
+            To restrict the logging of events in the appender\r
+            override the <see cref="M:PreAppendCheck()"/> method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Append a bulk array of logging events.\r
+            </summary>\r
+            <param name="loggingEvents">the array of logging events</param>\r
+            <remarks>\r
+            <para>\r
+            This base class implementation calls the <see cref="M:Append(LoggingEvent)"/>\r
+            method for each element in the bulk array.\r
+            </para>\r
+            <para>\r
+            A sub class that can better process a bulk array of events should\r
+            override this method in addition to <see cref="M:Append(LoggingEvent)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">\r
+            <summary>\r
+            Called before <see cref="M:Append(LoggingEvent)"/> as a precondition.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method is called by <see cref="M:DoAppend(LoggingEvent)"/>\r
+            before the call to the abstract <see cref="M:Append(LoggingEvent)"/> method.\r
+            </para>\r
+            <para>\r
+            This method can be overridden in a subclass to extend the checks \r
+            made before the event is passed to the <see cref="M:Append(LoggingEvent)"/> method.\r
+            </para>\r
+            <para>\r
+            A subclass should ensure that they delegate this call to\r
+            this base class if it is overridden.\r
+            </para>\r
+            </remarks>\r
+            <returns><c>true</c> if the call to <see cref="M:Append(LoggingEvent)"/> should proceed.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.\r
+            </summary>\r
+            <param name="loggingEvent">The event to render.</param>\r
+            <returns>The event rendered as a string.</returns>\r
+            <remarks>\r
+            <para>\r
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to \r
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>\r
+            set to render the <paramref name="loggingEvent"/> to \r
+            a string.\r
+            </para>\r
+            <para>If there is exception data in the logging event and \r
+            the layout does not process the exception, this method \r
+            will append the exception text to the rendered string.\r
+            </para>\r
+            <para>\r
+            Where possible use the alternative version of this method\r
+            <see cref="M:RenderLoggingEvent(TextWriter,LoggingEvent)"/>.\r
+            That method streams the rendering onto an existing Writer\r
+            which can give better performance if the caller already has\r
+            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.\r
+            </summary>\r
+            <param name="loggingEvent">The event to render.</param>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <remarks>\r
+            <para>\r
+            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to \r
+            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>\r
+            set to render the <paramref name="loggingEvent"/> to \r
+            a string.\r
+            </para>\r
+            <para>If there is exception data in the logging event and \r
+            the layout does not process the exception, this method \r
+            will append the exception text to the rendered string.\r
+            </para>\r
+            <para>\r
+            Use this method in preference to <see cref="M:RenderLoggingEvent(LoggingEvent)"/>\r
+            where possible. If, however, the caller needs to render the event\r
+            to a string then <see cref="M:RenderLoggingEvent(LoggingEvent)"/> does\r
+            provide an efficient mechanism for doing so.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">\r
+            <summary>\r
+            The layout of this appender.\r
+            </summary>\r
+            <remarks>\r
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_name">\r
+            <summary>\r
+            The name of this appender.\r
+            </summary>\r
+            <remarks>\r
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">\r
+            <summary>\r
+            The level threshold of this appender.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            There is no level threshold filtering by default.\r
+            </para>\r
+            <para>\r
+            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">\r
+            <summary>\r
+            It is assumed and enforced that errorHandler is never null.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            It is assumed and enforced that errorHandler is never null.\r
+            </para>\r
+            <para>\r
+            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">\r
+            <summary>\r
+            The first filter in the filter chain.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Set to <c>null</c> initially.\r
+            </para>\r
+            <para>\r
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">\r
+            <summary>\r
+            The last filter in the filter chain.\r
+            </summary>\r
+            <remarks>\r
+            See <see cref="T:log4net.Filter.IFilter"/> for more information.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">\r
+            <summary>\r
+            Flag indicating if this appender is closed.\r
+            </summary>\r
+            <remarks>\r
+            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">\r
+            <summary>\r
+            The guard prevents an appender from repeatedly calling its own DoAppend method\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">\r
+            <summary>\r
+            StringWriter used to render events\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderSkeleton.declaringType">\r
+            <summary>\r
+            The fully qualified type of the AppenderSkeleton class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">\r
+            <summary>\r
+            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.\r
+            </summary>\r
+            <value>\r
+            The threshold <see cref="T:log4net.Core.Level"/> of the appender. \r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            All log events with lower level than the threshold level are ignored \r
+            by the appender.\r
+            </para>\r
+            <para>\r
+            In configuration files this option is specified by setting the\r
+            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level\r
+            string, such as "DEBUG", "INFO" and so on.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.\r
+            </summary>\r
+            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default \r
+            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">\r
+            <summary>\r
+            The filter chain.\r
+            </summary>\r
+            <value>The head of the filter chain filter chain.</value>\r
+            <remarks>\r
+            <para>\r
+            Returns the head Filter. The Filters are organized in a linked list\r
+            and so all Filters on this Appender are available through the result.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderSkeleton.Layout">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.\r
+            </summary>\r
+            <value>The layout of the appender.</value>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderSkeleton.Name">\r
+            <summary>\r
+            Gets or sets the name of this appender.\r
+            </summary>\r
+            <value>The name of the appender.</value>\r
+            <remarks>\r
+            <para>\r
+            The name uniquely identifies the appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">\r
+            <summary>\r
+            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            In the rather exceptional case, where the appender \r
+            implementation admits a layout but can also work without it, \r
+            then the appender should return <c>true</c>.\r
+            </para>\r
+            <para>\r
+            This default implementation always returns <c>false</c>.\r
+            </para>\r
+            </remarks>\r
+            <returns>\r
+            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.\r
+            </returns>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">\r
+            <summary>\r
+            The default buffer size.\r
+            </summary>\r
+            <remarks>\r
+            The default size of the cyclic buffer used to store events.\r
+            This is set to 512 by default.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Protected default constructor to allow subclassing.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.\r
+            </summary>\r
+            <param name="eventMustBeFixed">the events passed through this appender must be\r
+            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>\r
+            <remarks>\r
+            <para>\r
+            Protected constructor to allow subclassing.\r
+            </para>\r
+            <para>\r
+            The <paramref name="eventMustBeFixed"/> should be set if the subclass\r
+            expects the events delivered to be fixed even if the \r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">\r
+            <summary>\r
+            Flush the currently buffered events\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Flushes any events that have been buffered.\r
+            </para>\r
+            <para>\r
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents\r
+            of the buffer will NOT be flushed to the appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">\r
+            <summary>\r
+            Flush the currently buffered events\r
+            </summary>\r
+            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>\r
+            <remarks>\r
+            <para>\r
+            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is\r
+            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.\r
+            </para>\r
+            <para>\r
+            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents\r
+            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.\r
+            In this case the contents of the buffer will be tested against the \r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered\r
+            events will be discarded.\r
+            </para>\r
+            <para>\r
+            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always\r
+            be emptied by calling this method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">\r
+            <summary>\r
+            Close this appender instance.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close this appender instance. If this appender is marked\r
+            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in \r
+            the buffer must be sent when the appender is closed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. \r
+            </summary>\r
+            <param name="loggingEvent">the event to log</param>\r
+            <remarks>\r
+            <para>\r
+            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.\r
+            </para>\r
+            <para>\r
+            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> \r
+            method) if one of the following conditions is met:\r
+            </para>\r
+            <list type="bullet">\r
+               <item>\r
+                       <description>The cyclic buffer is full and this appender is\r
+                       marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>\r
+               </item>\r
+               <item>\r
+                       <description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and\r
+                       it is triggered for the <paramref name="loggingEvent"/>\r
+                       specified.</description>\r
+               </item>\r
+            </list>\r
+            <para>\r
+            Before the event is stored in the buffer it is fixed\r
+            (see <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/>) to ensure that\r
+            any data referenced by the event will be valid when the buffer\r
+            is processed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">\r
+            <summary>\r
+            Sends the contents of the buffer.\r
+            </summary>\r
+            <param name="firstLoggingEvent">The first logging event.</param>\r
+            <param name="buffer">The buffer containing the events that need to be send.</param>\r
+            <remarks>\r
+            <para>\r
+            The subclass must override <see cref="M:SendBuffer(LoggingEvent[])"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Sends the events.\r
+            </summary>\r
+            <param name="events">The events that need to be send.</param>\r
+            <remarks>\r
+            <para>\r
+            The subclass must override this method to process the buffered events.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">\r
+            <summary>\r
+            The size of the cyclic buffer used to hold the logging events.\r
+            </summary>\r
+            <remarks>\r
+            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">\r
+            <summary>\r
+            The cyclic buffer used to store the logging events.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">\r
+            <summary>\r
+            The triggering event evaluator that causes the buffer to be sent immediately.\r
+            </summary>\r
+            <remarks>\r
+            The object that is used to determine if an event causes the entire\r
+            buffer to be sent immediately. This field can be <c>null</c>, which \r
+            indicates that event triggering is not to be done. The evaluator\r
+            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender\r
+            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to \r
+            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">\r
+            <summary>\r
+            Indicates if the appender should overwrite events in the cyclic buffer \r
+            when it becomes full, or if the buffer should be flushed when the \r
+            buffer is full.\r
+            </summary>\r
+            <remarks>\r
+            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must \r
+            be set.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">\r
+            <summary>\r
+            The triggering event evaluator filters discarded events.\r
+            </summary>\r
+            <remarks>\r
+            The object that is used to determine if an event that is discarded should\r
+            really be discarded or if it should be sent to the appenders. \r
+            This field can be <c>null</c>, which indicates that all discarded events will\r
+            be discarded. \r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">\r
+            <summary>\r
+            Value indicating which fields in the event should be fixed\r
+            </summary>\r
+            <remarks>\r
+            By default all fields are fixed\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">\r
+            <summary>\r
+            The events delivered to the subclass must be fixed.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">\r
+            <summary>\r
+            Gets or sets a value that indicates whether the appender is lossy.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This appender uses a buffer to store logging events before \r
+            delivering them. A triggering event causes the whole buffer\r
+            to be send to the remote sink. If the buffer overruns before\r
+            a triggering event then logging events could be lost. Set\r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events \r
+            from being lost.\r
+            </para>\r
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an\r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">\r
+            <summary>\r
+            Gets or sets the size of the cyclic buffer used to hold the \r
+            logging events.\r
+            </summary>\r
+            <value>\r
+            The size of the cyclic buffer used to hold the logging events.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer\r
+            representing the maximum number of logging events to collect in \r
+            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,\r
+            oldest events are deleted as new events are added to the\r
+            buffer. By default the size of the cyclic buffer is 512 events.\r
+            </para>\r
+            <para>\r
+            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than\r
+            or equal to 1 then no buffering will occur. The logging event\r
+            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>\r
+            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will\r
+            be buffered.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the \r
+            buffer to be sent immediately.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be\r
+            sent immediately.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The evaluator will be called for each event that is appended to this \r
+            appender. If the evaluator triggers then the current buffer will \r
+            immediately be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).\r
+            </para>\r
+            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an\r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">\r
+            <summary>\r
+            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.\r
+            </summary>\r
+            <value>\r
+            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The evaluator will be called for each event that is discarded from this \r
+            appender. If the evaluator triggers then the current buffer will immediately \r
+            be sent (see <see cref="M:SendBuffer(LoggingEvent[])"/>).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">\r
+            <summary>\r
+            Gets or sets a value indicating if only part of the logging event data\r
+            should be fixed.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if the appender should only fix part of the logging event \r
+            data, otherwise <c>false</c>. The default is <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Setting this property to <c>true</c> will cause only part of the\r
+            event data to be fixed and serialized. This will improve performance.\r
+            </para>\r
+            <para>\r
+            See <see cref="M:LoggingEvent.FixVolatileData(FixFlags)"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">\r
+            <summary>\r
+            Gets or sets a the fields that will be fixed in the event\r
+            </summary>\r
+            <value>\r
+            The event fields that will be fixed before the event is buffered\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The logging event needs to have certain thread specific values \r
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>\r
+            for details.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.#ctor">\r
+            <summary> \r
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            Public default constructor to initialize a new instance of this class.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.OnClose">\r
+            <summary>\r
+            Override the parent method to close the database\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Closes the database command and database connection.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Inserts the events into the database.\r
+            </summary>\r
+            <param name="events">The events to insert into the database.</param>\r
+            <remarks>\r
+            <para>\r
+            Insert all the events specified in the <paramref name="events"/>\r
+            array into the database.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">\r
+            <summary>\r
+            Adds a parameter to the command.\r
+            </summary>\r
+            <param name="parameter">The parameter to add to the command.</param>\r
+            <remarks>\r
+            <para>\r
+            Adds a parameter to the ordered list of command parameters.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Writes the events to the database using the transaction specified.\r
+            </summary>\r
+            <param name="dbTran">The transaction that the events will be executed under.</param>\r
+            <param name="events">The array of events to insert into the database.</param>\r
+            <remarks>\r
+            <para>\r
+            The transaction argument can be <c>null</c> if the appender has been\r
+            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>\r
+            property for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Formats the log message into database statement text.\r
+            </summary>\r
+            <param name="logEvent">The event being logged.</param>\r
+            <remarks>\r
+            This method can be overridden by subclasses to provide \r
+            more control over the format of the database statement.\r
+            </remarks>\r
+            <returns>\r
+            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.CreateConnection(System.Type,System.String)">\r
+            <summary>\r
+            Creates an <see cref="T:System.Data.IDbConnection"/> instance used to connect to the database.\r
+            </summary>\r
+            <remarks>\r
+            This method is called whenever a new IDbConnection is needed (i.e. when a reconnect is necessary).\r
+            </remarks>\r
+            <param name="connectionType">The <see cref="T:System.Type"/> of the <see cref="T:System.Data.IDbConnection"/> object.</param>\r
+            <param name="connectionString">The connectionString output from the ResolveConnectionString method.</param>\r
+            <returns>An <see cref="T:System.Data.IDbConnection"/> instance with a valid connection string.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionString(System.String@)">\r
+            <summary>\r
+            Resolves the connection string from the ConnectionString, ConnectionStringName, or AppSettingsKey\r
+            property.\r
+            </summary>\r
+            <remarks>\r
+            ConnectiongStringName is only supported on .NET 2.0 and higher.\r
+            </remarks>\r
+            <param name="connectionStringContext">Additional information describing the connection string.</param>\r
+            <returns>A connection string used to connect to the database.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">\r
+            <summary>\r
+            Retrieves the class type of the ADO.NET provider.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Gets the Type of the ADO.NET provider to use to connect to the\r
+            database. This method resolves the type specified in the \r
+            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.\r
+            </para>\r
+            <para>\r
+            Subclasses can override this method to return a different type\r
+            if necessary.\r
+            </para>\r
+            </remarks>\r
+            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseCommand">\r
+            <summary>\r
+            Prepares the database command and initialize the parameters.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">\r
+            <summary>\r
+            Connects to the database.\r
+            </summary>         \r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.DisposeCommand(System.Boolean)">\r
+            <summary>\r
+            Cleanup the existing command.\r
+            </summary>\r
+            <param name="ignoreException">\r
+            If true, a message will be written using LogLog.Warn if an exception is encountered when calling Dispose.\r
+            </param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppender.DiposeConnection">\r
+            <summary>\r
+            Cleanup the existing connection.\r
+            </summary>\r
+            <remarks>\r
+            Calls the IDbConnection's <see cref="M:System.Data.IDbConnection.Close"/> method.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_usePreparedCommand">\r
+            <summary>\r
+            Flag to indicate if we are using a command object\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Set to <c>true</c> when the appender is to use a prepared\r
+            statement or stored procedure to insert into the database.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">\r
+            <summary>\r
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">\r
+            <summary>\r
+            The security context to use for privileged calls\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">\r
+            <summary>\r
+            The <see cref="T:System.Data.IDbConnection"/> that will be used\r
+            to insert logging events into a database.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_dbCommand">\r
+            <summary>\r
+            The database command.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">\r
+            <summary>\r
+            Database connection string.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_appSettingsKey">\r
+            <summary>\r
+            The appSettings key from App.Config that contains the connection string.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionStringName">\r
+            <summary>\r
+            The connectionStrings key from App.Config that contains the connection string.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">\r
+            <summary>\r
+            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">\r
+            <summary>\r
+            The text of the command.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">\r
+            <summary>\r
+            The command type.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">\r
+            <summary>\r
+            Indicates whether to use transactions when writing to the database.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">\r
+            <summary>\r
+            Indicates whether to use transactions when writing to the database.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppender.declaringType">\r
+            <summary>\r
+            The fully qualified type of the AdoNetAppender class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">\r
+            <summary>\r
+            Gets or sets the database connection string that is used to connect to \r
+            the database.\r
+            </summary>\r
+            <value>\r
+            The database connection string used to connect to the database.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The connections string is specific to the connection type.\r
+            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.\r
+            </para>\r
+            </remarks>\r
+            <example>Connection string for MS Access via ODBC:\r
+            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>\r
+            </example>\r
+            <example>Another connection string for MS Access via ODBC:\r
+            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>\r
+            </example>\r
+            <example>Connection string for MS Access via OLE DB:\r
+            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>\r
+            </example>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.AppSettingsKey">\r
+            <summary>\r
+            The appSettings key from App.Config that contains the connection string.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionStringName">\r
+            <summary>\r
+            The connectionStrings key from App.Config that contains the connection string.\r
+            </summary>\r
+            <remarks>\r
+            This property requires at least .NET 2.0.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">\r
+            <summary>\r
+            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection\r
+            that should be created.\r
+            </summary>\r
+            <value>\r
+            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The type name of the ADO.NET provider to use.\r
+            </para>\r
+            <para>\r
+            The default is to use the OLE DB provider.\r
+            </para>\r
+            </remarks>\r
+            <example>Use the OLE DB Provider. This is the default value.\r
+            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>\r
+            </example>\r
+            <example>Use the MS SQL Server Provider. \r
+            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>\r
+            </example>\r
+            <example>Use the ODBC Provider. \r
+            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>\r
+            This is an optional package that you can download from \r
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> \r
+            search for <b>ODBC .NET Data Provider</b>.\r
+            </example>\r
+            <example>Use the Oracle Provider. \r
+            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>\r
+            This is an optional package that you can download from \r
+            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> \r
+            search for <b>.NET Managed Provider for Oracle</b>.\r
+            </example>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.CommandText">\r
+            <summary>\r
+            Gets or sets the command text that is used to insert logging events\r
+            into the database.\r
+            </summary>\r
+            <value>\r
+            The command text used to insert logging events into the database.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Either the text of the prepared statement or the\r
+            name of the stored procedure to execute to write into\r
+            the database.\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if\r
+            this text is a prepared statement or a stored procedure.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.CommandType">\r
+            <summary>\r
+            Gets or sets the command type to execute.\r
+            </summary>\r
+            <value>\r
+            The command type to execute.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify\r
+            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, \r
+            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the\r
+            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure\r
+            to execute.\r
+            </para>\r
+            <para>\r
+            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">\r
+            <summary>\r
+            Should transactions be used to insert logging events in the database.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if transactions should be used to insert logging events in\r
+            the database, otherwise <c>false</c>. The default value is <c>true</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets a value that indicates whether transactions should be used\r
+            to insert logging events in the database.\r
+            </para>\r
+            <para>\r
+            When set a single transaction will be used to insert the buffered events\r
+            into the database. Otherwise each event will be inserted without using\r
+            an explicit transaction.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender\r
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the\r
+            security context to use. The default behavior is to use the security context\r
+            of the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">\r
+            <summary>\r
+            Should this appender try to reconnect to the database on error.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if the appender should try to reconnect to the database after an\r
+            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, \r
+            i.e. not to try to reconnect.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The default behaviour is for the appender not to try to reconnect to the\r
+            database if an error occurs. Subsequent logging events are discarded.\r
+            </para>\r
+            <para>\r
+            To force the appender to attempt to reconnect to the database set this\r
+            property to <c>true</c>.\r
+            </para>\r
+            <note>\r
+            When the appender attempts to connect to the database there may be a\r
+            delay of up to the connection timeout specified in the connection string.\r
+            This delay will block the calling application's thread. \r
+            Until the connection can be reestablished this potential delay may occur multiple times.\r
+            </note>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppender.Connection">\r
+            <summary>\r
+            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.\r
+            </summary>\r
+            <value>\r
+            The underlying <see cref="T:System.Data.IDbConnection"/>.\r
+            </value>\r
+            <remarks>\r
+            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert \r
+            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> \r
+            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the \r
+            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if \r
+            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.AdoNetAppenderParameter">\r
+            <summary>\r
+            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class provides the basic database parameter properties\r
+            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.\r
+            </para>\r
+            <para>This type can be subclassed to provide database specific\r
+            functionality. The two methods that are called externally are\r
+            <see cref="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)"/> and <see cref="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> class.\r
+            </summary>\r
+            <remarks>\r
+            Default constructor for the AdoNetAppenderParameter class.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.Prepare(System.Data.IDbCommand)">\r
+            <summary>\r
+            Prepare the specified database command object.\r
+            </summary>\r
+            <param name="command">The command to prepare.</param>\r
+            <remarks>\r
+            <para>\r
+            Prepares the database command object by adding\r
+            this parameter to its collection of parameters.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AdoNetAppenderParameter.FormatValue(System.Data.IDbCommand,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Renders the logging event and set the parameter value in the command.\r
+            </summary>\r
+            <param name="command">The command containing the parameter.</param>\r
+            <param name="loggingEvent">The event to be rendered.</param>\r
+            <remarks>\r
+            <para>\r
+            Renders the logging event using this parameters layout\r
+            object. Sets the value of the parameter on the command object.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_parameterName">\r
+            <summary>\r
+            The name of this parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_dbType">\r
+            <summary>\r
+            The database type for this parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_inferType">\r
+            <summary>\r
+            Flag to infer type rather than use the DbType\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_precision">\r
+            <summary>\r
+            The precision for this parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_scale">\r
+            <summary>\r
+            The scale for this parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_size">\r
+            <summary>\r
+            The size for this parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AdoNetAppenderParameter.m_layout">\r
+            <summary>\r
+            The <see cref="T:log4net.Layout.IRawLayout"/> to use to render the\r
+            logging event into an object for this parameter.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.ParameterName">\r
+            <summary>\r
+            Gets or sets the name of this parameter.\r
+            </summary>\r
+            <value>\r
+            The name of this parameter.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of this parameter. The parameter name\r
+            must match up to a named parameter to the SQL stored procedure\r
+            or prepared statement.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.DbType">\r
+            <summary>\r
+            Gets or sets the database type for this parameter.\r
+            </summary>\r
+            <value>\r
+            The database type for this parameter.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The database type for this parameter. This property should\r
+            be set to the database type from the <see cref="P:log4net.Appender.AdoNetAppenderParameter.DbType"/>\r
+            enumeration. See <see cref="P:System.Data.IDataParameter.DbType"/>.\r
+            </para>\r
+            <para>\r
+            This property is optional. If not specified the ADO.NET provider \r
+            will attempt to infer the type from the value.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:System.Data.IDataParameter.DbType"/>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Precision">\r
+            <summary>\r
+            Gets or sets the precision for this parameter.\r
+            </summary>\r
+            <value>\r
+            The precision for this parameter.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The maximum number of digits used to represent the Value.\r
+            </para>\r
+            <para>\r
+            This property is optional. If not specified the ADO.NET provider \r
+            will attempt to infer the precision from the value.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:System.Data.IDbDataParameter.Precision"/>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Scale">\r
+            <summary>\r
+            Gets or sets the scale for this parameter.\r
+            </summary>\r
+            <value>\r
+            The scale for this parameter.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The number of decimal places to which Value is resolved.\r
+            </para>\r
+            <para>\r
+            This property is optional. If not specified the ADO.NET provider \r
+            will attempt to infer the scale from the value.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:System.Data.IDbDataParameter.Scale"/>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Size">\r
+            <summary>\r
+            Gets or sets the size for this parameter.\r
+            </summary>\r
+            <value>\r
+            The size for this parameter.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The maximum size, in bytes, of the data within the column.\r
+            </para>\r
+            <para>\r
+            This property is optional. If not specified the ADO.NET provider \r
+            will attempt to infer the size from the value.\r
+            </para>\r
+            <para>\r
+            For BLOB data types like VARCHAR(max) it may be impossible to infer the value automatically, use -1 as the size in this case.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:System.Data.IDbDataParameter.Size"/>\r
+        </member>\r
+        <member name="P:log4net.Appender.AdoNetAppenderParameter.Layout">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Layout.IRawLayout"/> to use to \r
+            render the logging event into an object for this \r
+            parameter.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Layout.IRawLayout"/> used to render the\r
+            logging event into an object for this parameter.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Layout.IRawLayout"/> that renders the value for this\r
+            parameter.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Layout.RawLayoutConverter"/> can be used to adapt\r
+            any <see cref="T:log4net.Layout.ILayout"/> into a <see cref="T:log4net.Layout.IRawLayout"/>\r
+            for use in the property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender">\r
+            <summary>\r
+            Appends logging events to the terminal using ANSI color escape sequences.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            AnsiColorTerminalAppender appends log events to the standard output stream\r
+            or the error output stream using a layout specified by the \r
+            user. It also allows the color of a specific level of message to be set.\r
+            </para>\r
+            <note>\r
+            This appender expects the terminal to understand the VT100 control set \r
+            in order to interpret the color codes. If the terminal or console does not\r
+            understand the control codes the behavior is not defined.\r
+            </note>\r
+            <para>\r
+            By default, all output is written to the console's standard output stream.\r
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> property can be set to direct the output to the\r
+            error stream.\r
+            </para>\r
+            <para>\r
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or \r
+            <c>System.Console.Error</c> that is set at the time the event is appended.\r
+            Therefore it is possible to programmatically redirect the output of this appender \r
+            (for example NUnit does this to capture program output). While this is the desired\r
+            behavior of this appender it may have security implications in your application. \r
+            </para>\r
+            <para>\r
+            When configuring the ANSI colored terminal appender, a mapping should be\r
+            specified to map a logging level to a color. For example:\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <mapping>\r
+               <level value="ERROR"/>\r
+               <foreColor value="White"/>\r
+               <backColor value="Red"/>\r
+                <attributes value="Bright,Underscore"/>\r
+            </mapping>\r
+            <mapping>\r
+               <level value="DEBUG"/>\r
+               <backColor value="Green"/>\r
+            </mapping>\r
+            </code>\r
+            <para>\r
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any\r
+            of the following values:\r
+            <list type="bullet">\r
+            <item><term>Blue</term><description></description></item>\r
+            <item><term>Green</term><description></description></item>\r
+            <item><term>Red</term><description></description></item>\r
+            <item><term>White</term><description></description></item>\r
+            <item><term>Yellow</term><description></description></item>\r
+            <item><term>Purple</term><description></description></item>\r
+            <item><term>Cyan</term><description></description></item>\r
+            </list>\r
+            These color values cannot be combined together to make new colors.\r
+            </para>\r
+            <para>\r
+            The attributes can be any combination of the following:\r
+            <list type="bullet">\r
+            <item><term>Bright</term><description>foreground is brighter</description></item>\r
+            <item><term>Dim</term><description>foreground is dimmer</description></item>\r
+            <item><term>Underscore</term><description>message is underlined</description></item>\r
+            <item><term>Blink</term><description>foreground is blinking (does not work on all terminals)</description></item>\r
+            <item><term>Reverse</term><description>foreground and background are reversed</description></item>\r
+            <item><term>Hidden</term><description>output is hidden</description></item>\r
+            <item><term>Strikethrough</term><description>message has a line through it</description></item>\r
+            </list>\r
+            While any of these attributes may be combined together not all combinations\r
+            work well together, for example setting both <i>Bright</i> and <i>Dim</i> attributes makes\r
+            no sense.\r
+            </para>\r
+            </remarks>\r
+            <author>Patrick Wagstrom</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleOut">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.ConsoleError">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.AnsiColorTerminalAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.PostEventCodes">\r
+            <summary>\r
+            Ansi code to reset terminal\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            The instance of the <see cref="T:log4net.Appender.AnsiColorTerminalAppender"/> class is set up to write \r
+            to the standard output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.AddMapping(log4net.Appender.AnsiColorTerminalAppender.LevelColors)">\r
+            <summary>\r
+            Add a mapping of level to color\r
+            </summary>\r
+            <param name="mapping">The mapping to add</param>\r
+            <remarks>\r
+            <para>\r
+            Add a <see cref="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors"/> mapping to this appender.\r
+            Each mapping defines the foreground and background colours\r
+            for a level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the event to the console.\r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the options for this appender\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initialize the level to color mappings set on this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_writeToErrorStream">\r
+            <summary>\r
+            Flag to write output to the error stream rather than the standard output stream\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.m_levelMapping">\r
+            <summary>\r
+            Mapping from level object to color value\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.Target">\r
+            <summary>\r
+            Target is the value of the console output stream.\r
+            </summary>\r
+            <value>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes">\r
+            <summary>\r
+            The enum of possible display attributes\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The following flags can be combined together to\r
+            form the ANSI color attributes.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Bright">\r
+            <summary>\r
+            text is bright\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Dim">\r
+            <summary>\r
+            text is dim\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Underscore">\r
+            <summary>\r
+            text is underlined\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Blink">\r
+            <summary>\r
+            text is blinking\r
+            </summary>\r
+            <remarks>\r
+            Not all terminals support this attribute\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Reverse">\r
+            <summary>\r
+            text and background colors are reversed\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Hidden">\r
+            <summary>\r
+            text is hidden\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Strikethrough">\r
+            <summary>\r
+            text is displayed with a strikethrough\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiAttributes.Light">\r
+            <summary>\r
+            text color is light\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.AnsiColor">\r
+            <summary>\r
+            The enum of possible foreground or background color values for \r
+            use with the color mapping method\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The output can be in one for the following ANSI colors.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Appender.AnsiColorTerminalAppender"/>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Black">\r
+            <summary>\r
+            color is black\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Red">\r
+            <summary>\r
+            color is red\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Green">\r
+            <summary>\r
+            color is green\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Yellow">\r
+            <summary>\r
+            color is yellow\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Blue">\r
+            <summary>\r
+            color is blue\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Magenta">\r
+            <summary>\r
+            color is magenta\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.Cyan">\r
+            <summary>\r
+            color is cyan\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.AnsiColorTerminalAppender.AnsiColor.White">\r
+            <summary>\r
+            color is white\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AnsiColorTerminalAppender.LevelColors">\r
+            <summary>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the color it should be displayed as.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defines the mapping between a level and the color it should be displayed in.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.LevelMappingEntry">\r
+            <summary>\r
+            An entry in the <see cref="T:log4net.Util.LevelMapping"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is an abstract base class for types that are stored in the\r
+            <see cref="T:log4net.Util.LevelMapping"/> object.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.LevelMappingEntry.#ctor">\r
+            <summary>\r
+            Default protected constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default protected constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LevelMappingEntry.ActivateOptions">\r
+            <summary>\r
+            Initialize any options defined on this entry\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Should be overridden by any classes that need to initialise based on their options\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.LevelMappingEntry.Level">\r
+            <summary>\r
+            The level that is the key for this mapping \r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this mapping \r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Get or set the <see cref="P:log4net.Util.LevelMappingEntry.Level"/> that is the key for this\r
+            mapping subclass.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ActivateOptions">\r
+            <summary>\r
+            Initialize the options for the object\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Combine the <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> together\r
+            and append the attributes.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor">\r
+            <summary>\r
+            The mapped foreground color for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped foreground color for the specified level\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor">\r
+            <summary>\r
+            The mapped background color for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped background color for the specified level\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes">\r
+            <summary>\r
+            The color attributes for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The color attributes for the specified level\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.CombinedColor">\r
+            <summary>\r
+            The combined <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.ForeColor"/>, <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.BackColor"/> and\r
+            <see cref="P:log4net.Appender.AnsiColorTerminalAppender.LevelColors.Attributes"/> suitable for setting the ansi terminal color.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AppenderCollection">\r
+            <summary>\r
+            A strongly-typed collection of <see cref="T:log4net.Appender.IAppender"/> objects.\r
+            </summary>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.ReadOnly(log4net.Appender.AppenderCollection)">\r
+            <summary>\r
+            Creates a read-only wrapper for a <c>AppenderCollection</c> instance.\r
+            </summary>\r
+            <param name="list">list to create a readonly wrapper arround</param>\r
+            <returns>\r
+            An <c>AppenderCollection</c> wrapper that is read-only.\r
+            </returns>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderCollection.EmptyCollection">\r
+            <summary>\r
+            An empty readonly static AppenderCollection\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <c>AppenderCollection</c> class\r
+            that is empty and has the default initial capacity.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Int32)">\r
+            <summary>\r
+            Initializes a new instance of the <c>AppenderCollection</c> class\r
+            that has the specified initial capacity.\r
+            </summary>\r
+            <param name="capacity">\r
+            The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.\r
+            </param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>AppenderCollection</c> class\r
+            that contains elements copied from the specified <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="c">The <c>AppenderCollection</c> whose elements are copied to the new collection.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Initializes a new instance of the <c>AppenderCollection</c> class\r
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> array.\r
+            </summary>\r
+            <param name="a">The <see cref="T:log4net.Appender.IAppender"/> array whose elements are copied to the new list.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(System.Collections.ICollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>AppenderCollection</c> class\r
+            that contains elements copied from the specified <see cref="T:log4net.Appender.IAppender"/> collection.\r
+            </summary>\r
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements are copied to the new list.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.#ctor(log4net.Appender.AppenderCollection.Tag)">\r
+            <summary>\r
+            Allow subclasses to avoid our default constructors\r
+            </summary>\r
+            <param name="tag"></param>\r
+            <exclude/>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional\r
+            <see cref="T:log4net.Appender.IAppender"/> array.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.CopyTo(log4net.Appender.IAppender[],System.Int32)">\r
+            <summary>\r
+            Copies the entire <c>AppenderCollection</c> to a one-dimensional\r
+            <see cref="T:log4net.Appender.IAppender"/> array, starting at the specified index of the target array.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:log4net.Appender.IAppender"/> array to copy to.</param>\r
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Add(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Adds a <see cref="T:log4net.Appender.IAppender"/> to the end of the <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to be added to the end of the <c>AppenderCollection</c>.</param>\r
+            <returns>The index at which the value has been added.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Clear">\r
+            <summary>\r
+            Removes all elements from the <c>AppenderCollection</c>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Clone">\r
+            <summary>\r
+            Creates a shallow copy of the <see cref="T:log4net.Appender.AppenderCollection"/>.\r
+            </summary>\r
+            <returns>A new <see cref="T:log4net.Appender.AppenderCollection"/> with a shallow copy of the collection data.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Contains(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Determines whether a given <see cref="T:log4net.Appender.IAppender"/> is in the <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to check for.</param>\r
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>AppenderCollection</c>; otherwise, <c>false</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.IndexOf(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Appender.IAppender"/>\r
+            in the <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to locate in the <c>AppenderCollection</c>.</param>\r
+            <returns>\r
+            The zero-based index of the first occurrence of <paramref name="item"/> \r
+            in the entire <c>AppenderCollection</c>, if found; otherwise, -1.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Insert(System.Int32,log4net.Appender.IAppender)">\r
+            <summary>\r
+            Inserts an element into the <c>AppenderCollection</c> at the specified index.\r
+            </summary>\r
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>\r
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to insert.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Remove(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Removes the first occurrence of a specific <see cref="T:log4net.Appender.IAppender"/> from the <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Appender.IAppender"/> to remove from the <c>AppenderCollection</c>.</param>\r
+            <exception cref="T:System.ArgumentException">\r
+            The specified <see cref="T:log4net.Appender.IAppender"/> was not found in the <c>AppenderCollection</c>.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.RemoveAt(System.Int32)">\r
+            <summary>\r
+            Removes the element at the specified index of the <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="index">The zero-based index of the element to remove.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.GetEnumerator">\r
+            <summary>\r
+            Returns an enumerator that can iterate through the <c>AppenderCollection</c>.\r
+            </summary>\r
+            <returns>An <see cref="T:log4net.Appender.AppenderCollection.Enumerator"/> for the entire <c>AppenderCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.AppenderCollection)">\r
+            <summary>\r
+            Adds the elements of another <c>AppenderCollection</c> to the current <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="x">The <c>AppenderCollection</c> whose elements should be added to the end of the current <c>AppenderCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> array to the current <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="x">The <see cref="T:log4net.Appender.IAppender"/> array whose elements should be added to the end of the <c>AppenderCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.AddRange(System.Collections.ICollection)">\r
+            <summary>\r
+            Adds the elements of a <see cref="T:log4net.Appender.IAppender"/> collection to the current <c>AppenderCollection</c>.\r
+            </summary>\r
+            <param name="col">The <see cref="T:log4net.Appender.IAppender"/> collection whose elements should be added to the end of the <c>AppenderCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Appender.AppenderCollection.Count"/> of the <c>AppenderCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.TrimToSize">\r
+            <summary>\r
+            Sets the capacity to the actual number of elements.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.ToArray">\r
+            <summary>\r
+            Return the collection elements as an array\r
+            </summary>\r
+            <returns>the array</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32)">\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="i"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.ValidateIndex(System.Int32,System.Boolean)">\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="i"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.Count">\r
+            <summary>\r
+            Gets the number of elements actually contained in the <c>AppenderCollection</c>.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.IsSynchronized">\r
+            <summary>\r
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).\r
+            </summary>\r
+            <returns>true if access to the ICollection is synchronized (thread-safe); otherwise, false.</returns>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.SyncRoot">\r
+            <summary>\r
+            Gets an object that can be used to synchronize access to the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.Item(System.Int32)">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Appender.IAppender"/> at the specified index.\r
+            </summary>\r
+            <param name="index">The zero-based index of the element to get or set.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+               <para><paramref name="index"/> is less than zero</para>\r
+               <para>-or-</para>\r
+               <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Appender.AppenderCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.IsFixedSize">\r
+            <summary>\r
+            Gets a value indicating whether the collection has a fixed size.\r
+            </summary>\r
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.IsReadOnly">\r
+            <summary>\r
+            Gets a value indicating whether the IList is read-only.\r
+            </summary>\r
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.Capacity">\r
+            <summary>\r
+            Gets or sets the number of elements the <c>AppenderCollection</c> can contain.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator">\r
+            <summary>\r
+            Supports type-safe iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.\r
+            </summary>\r
+            <exclude/>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.MoveNext">\r
+            <summary>\r
+            Advances the enumerator to the next element in the collection.\r
+            </summary>\r
+            <returns>\r
+            <c>true</c> if the enumerator was successfully advanced to the next element; \r
+            <c>false</c> if the enumerator has passed the end of the collection.\r
+            </returns>\r
+            <exception cref="T:System.InvalidOperationException">\r
+            The collection was modified after the enumerator was created.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Reset">\r
+            <summary>\r
+            Sets the enumerator to its initial position, before the first element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.IAppenderCollectionEnumerator.Current">\r
+            <summary>\r
+            Gets the current element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AppenderCollection.Tag">\r
+            <summary>\r
+            Type visible only to our subclasses\r
+            Used to access protected constructor\r
+            </summary>\r
+            <exclude/>\r
+        </member>\r
+        <member name="F:log4net.Appender.AppenderCollection.Tag.Default">\r
+            <summary>\r
+            A value\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AppenderCollection.Enumerator">\r
+            <summary>\r
+            Supports simple iteration over a <see cref="T:log4net.Appender.AppenderCollection"/>.\r
+            </summary>\r
+            <exclude/>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.#ctor(log4net.Appender.AppenderCollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>Enumerator</c> class.\r
+            </summary>\r
+            <param name="tc"></param>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.MoveNext">\r
+            <summary>\r
+            Advances the enumerator to the next element in the collection.\r
+            </summary>\r
+            <returns>\r
+            <c>true</c> if the enumerator was successfully advanced to the next element; \r
+            <c>false</c> if the enumerator has passed the end of the collection.\r
+            </returns>\r
+            <exception cref="T:System.InvalidOperationException">\r
+            The collection was modified after the enumerator was created.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.AppenderCollection.Enumerator.Reset">\r
+            <summary>\r
+            Sets the enumerator to its initial position, before the first element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AppenderCollection.Enumerator.Current">\r
+            <summary>\r
+            Gets the current element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.AppenderCollection.ReadOnlyAppenderCollection">\r
+            <exclude/>\r
+        </member>\r
+        <member name="T:log4net.Appender.AspNetTraceAppender">\r
+            <summary>\r
+            <para>\r
+            Appends log events to the ASP.NET <see cref="T:System.Web.TraceContext"/> system.\r
+            </para>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Diagnostic information and tracing messages that you specify are appended to the output \r
+            of the page that is sent to the requesting browser. Optionally, you can view this information\r
+            from a separate trace viewer (Trace.axd) that displays trace information for every page in a \r
+            given application.\r
+            </para>\r
+            <para>\r
+            Trace statements are processed and displayed only when tracing is enabled. You can control \r
+            whether tracing is displayed to a page, to the trace viewer, or both.\r
+            </para>\r
+            <para>\r
+            The logging event is passed to the <see cref="M:TraceContext.Write(string)"/> or \r
+            <see cref="M:TraceContext.Warn(string)"/> method depending on the level of the logging event.\r
+            The event's logger name is the default value for the category parameter of the Write/Warn method. \r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.AspNetTraceAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.AspNetTraceAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.AspNetTraceAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the logging event to the ASP.NET trace\r
+            </summary>\r
+            <param name="loggingEvent">the event to log</param>\r
+            <remarks>\r
+            <para>\r
+            Write the logging event to the ASP.NET trace\r
+            <c>HttpContext.Current.Trace</c> \r
+            (<see cref="T:System.Web.TraceContext"/>).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.AspNetTraceAppender.m_category">\r
+            <summary>\r
+            Defaults to %logger\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.AspNetTraceAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.AspNetTraceAppender.Category">\r
+            <summary>\r
+            The category parameter sent to the Trace method.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defaults to %logger which will use the logger name of the current \r
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.\r
+            </para>\r
+            <para>\r
+            </para> \r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.BufferingForwardingAppender">\r
+            <summary>\r
+            Buffers events and then forwards them to attached appenders.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The events are buffered in this appender until conditions are\r
+            met to allow the appender to deliver the events to the attached \r
+            appenders. See <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> for the\r
+            conditions that cause the buffer to be sent.\r
+            </para>\r
+            <para>The forwarding appender can be used to specify different \r
+            thresholds and filters for the same appender at different locations \r
+            within the hierarchy.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Core.IAppenderAttachable">\r
+            <summary>\r
+            Interface for attaching appenders to objects.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface for attaching, removing and retrieving appenders.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.IAppenderAttachable.AddAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Attaches an appender.\r
+            </summary>\r
+            <param name="appender">The appender to add.</param>\r
+            <remarks>\r
+            <para>\r
+            Add the specified appender. The implementation may\r
+            choose to allow or deny duplicate appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IAppenderAttachable.GetAppender(System.String)">\r
+            <summary>\r
+            Gets an attached appender with the specified name.\r
+            </summary>\r
+            <param name="name">The name of the appender to get.</param>\r
+            <returns>\r
+            The appender with the name specified, or <c>null</c> if no appender with the\r
+            specified name is found.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Returns an attached appender with the <paramref name="name"/> specified.\r
+            If no appender with the specified name is found <c>null</c> will be\r
+            returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAllAppenders">\r
+            <summary>\r
+            Removes all attached appenders.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Removes and closes all attached appenders\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Removes the specified appender from the list of attached appenders.\r
+            </summary>\r
+            <param name="appender">The appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            <para>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IAppenderAttachable.RemoveAppender(System.String)">\r
+            <summary>\r
+            Removes the appender with the specified name from the list of appenders.\r
+            </summary>\r
+            <param name="name">The name of the appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            <para>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.IAppenderAttachable.Appenders">\r
+            <summary>\r
+            Gets all attached appenders.\r
+            </summary>\r
+            <value>\r
+            A collection of attached appenders.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets a collection of attached appenders.\r
+            If there are no attached appenders the\r
+            implementation should return an empty \r
+            collection rather than <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingForwardingAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.OnClose">\r
+            <summary>\r
+            Closes the appender and releases resources.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Releases any resources allocated within the appender such as file handles, \r
+            network connections, etc.\r
+            </para>\r
+            <para>\r
+            It is a programming error to append to a closed appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.SendBuffer(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Send the events.\r
+            </summary>\r
+            <param name="events">The events that need to be send.</param>\r
+            <remarks>\r
+            <para>\r
+            Forwards the events to the attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.AddAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this\r
+            instance.\r
+            </summary>\r
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>\r
+            <remarks>\r
+            <para>\r
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of\r
+            appenders, then it won't be added again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.GetAppender(System.String)">\r
+            <summary>\r
+            Looks for the appender with the specified name.\r
+            </summary>\r
+            <param name="name">The name of the appender to lookup.</param>\r
+            <returns>\r
+            The appender with the specified name, or <c>null</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Get the named appender attached to this buffering appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAllAppenders">\r
+            <summary>\r
+            Removes all previously added appenders from this appender.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is useful when re-reading configuration information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Removes the specified appender from the list of appenders.\r
+            </summary>\r
+            <param name="appender">The appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.BufferingForwardingAppender.RemoveAppender(System.String)">\r
+            <summary>\r
+            Removes the appender with the specified name from the list of appenders.\r
+            </summary>\r
+            <param name="name">The name of the appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.BufferingForwardingAppender.m_appenderAttachedImpl">\r
+            <summary>\r
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.BufferingForwardingAppender.Appenders">\r
+            <summary>\r
+            Gets the appenders contained in this appender as an \r
+            <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <remarks>\r
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> \r
+            is returned.\r
+            </remarks>\r
+            <returns>\r
+            A collection of the appenders in this appender.\r
+            </returns>\r
+        </member>\r
+        <member name="T:log4net.Appender.ColoredConsoleAppender">\r
+            <summary>\r
+            Appends logging events to the console.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            ColoredConsoleAppender appends log events to the standard output stream\r
+            or the error output stream using a layout specified by the \r
+            user. It also allows the color of a specific type of message to be set.\r
+            </para>\r
+            <para>\r
+            By default, all output is written to the console's standard output stream.\r
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> property can be set to direct the output to the\r
+            error stream.\r
+            </para>\r
+            <para>\r
+            NOTE: This appender writes directly to the application's attached console\r
+            not to the <c>System.Console.Out</c> or <c>System.Console.Error</c> <c>TextWriter</c>.\r
+            The <c>System.Console.Out</c> and <c>System.Console.Error</c> streams can be\r
+            programmatically redirected (for example NUnit does this to capture program output).\r
+            This appender will ignore these redirections because it needs to use Win32\r
+            API calls to colorize the output. To respect these redirections the <see cref="T:log4net.Appender.ConsoleAppender"/>\r
+            must be used.\r
+            </para>\r
+            <para>\r
+            When configuring the colored console appender, mapping should be\r
+            specified to map a logging level to a color. For example:\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <mapping>\r
+               <level value="ERROR"/>\r
+               <foreColor value="White"/>\r
+               <backColor value="Red, HighIntensity"/>\r
+            </mapping>\r
+            <mapping>\r
+               <level value="DEBUG"/>\r
+               <backColor value="Green"/>\r
+            </mapping>\r
+            </code>\r
+            <para>\r
+            The Level is the standard log4net logging level and ForeColor and BackColor can be any\r
+            combination of the following values:\r
+            <list type="bullet">\r
+            <item><term>Blue</term><description></description></item>\r
+            <item><term>Green</term><description></description></item>\r
+            <item><term>Red</term><description></description></item>\r
+            <item><term>White</term><description></description></item>\r
+            <item><term>Yellow</term><description></description></item>\r
+            <item><term>Purple</term><description></description></item>\r
+            <item><term>Cyan</term><description></description></item>\r
+            <item><term>HighIntensity</term><description></description></item>\r
+            </list>\r
+            </para>\r
+            </remarks>\r
+            <author>Rick Hobbs</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleOut">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.ConsoleError">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.ColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write \r
+            to the standard output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class\r
+            with the specified layout.\r
+            </summary>\r
+            <param name="layout">the layout to use for this appender</param>\r
+            <remarks>\r
+            The instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class is set up to write \r
+            to the standard output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ColoredConsoleAppender"/> class\r
+            with the specified layout.\r
+            </summary>\r
+            <param name="layout">the layout to use for this appender</param>\r
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>\r
+            <remarks>\r
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to\r
+            the standard error output stream.  Otherwise, output is written to the standard\r
+            output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.AddMapping(log4net.Appender.ColoredConsoleAppender.LevelColors)">\r
+            <summary>\r
+            Add a mapping of level to color - done by the config file\r
+            </summary>\r
+            <param name="mapping">The mapping to add</param>\r
+            <remarks>\r
+            <para>\r
+            Add a <see cref="T:log4net.Appender.ColoredConsoleAppender.LevelColors"/> mapping to this appender.\r
+            Each mapping defines the foreground and background colors\r
+            for a level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the event to the console.\r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the options for this appender\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initialize the level to color mappings set on this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_writeToErrorStream">\r
+            <summary>\r
+            Flag to write output to the error stream rather than the standard output stream\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_levelMapping">\r
+            <summary>\r
+            Mapping from level object to color value\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.m_consoleOutputWriter">\r
+            <summary>\r
+            The console output stream writer to write to\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This writer is not thread safe.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ColoredConsoleAppender.Target">\r
+            <summary>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </summary>\r
+            <value>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ColoredConsoleAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.ColoredConsoleAppender.Colors">\r
+            <summary>\r
+            The enum of possible color values for use with the color mapping method\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The following flags can be combined together to\r
+            form the colors.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Appender.ColoredConsoleAppender"/>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Blue">\r
+            <summary>\r
+            color is blue\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Green">\r
+            <summary>\r
+            color is green\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Red">\r
+            <summary>\r
+            color is red\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.White">\r
+            <summary>\r
+            color is white\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Yellow">\r
+            <summary>\r
+            color is yellow\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Purple">\r
+            <summary>\r
+            color is purple\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.Cyan">\r
+            <summary>\r
+            color is cyan\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ColoredConsoleAppender.Colors.HighIntensity">\r
+            <summary>\r
+            color is intensified\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.ColoredConsoleAppender.LevelColors">\r
+            <summary>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the color it should be displayed as.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defines the mapping between a level and the color it should be displayed in.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ColoredConsoleAppender.LevelColors.ActivateOptions">\r
+            <summary>\r
+            Initialize the options for the object\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Combine the <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> together.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor">\r
+            <summary>\r
+            The mapped foreground color for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped foreground color for the specified level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor">\r
+            <summary>\r
+            The mapped background color for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped background color for the specified level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ColoredConsoleAppender.LevelColors.CombinedColor">\r
+            <summary>\r
+            The combined <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.ForeColor"/> and <see cref="P:log4net.Appender.ColoredConsoleAppender.LevelColors.BackColor"/> suitable for \r
+            setting the console color.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.ConsoleAppender">\r
+            <summary>\r
+            Appends logging events to the console.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            ConsoleAppender appends log events to the standard output stream\r
+            or the error output stream using a layout specified by the \r
+            user.\r
+            </para>\r
+            <para>\r
+            By default, all output is written to the console's standard output stream.\r
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> property can be set to direct the output to the\r
+            error stream.\r
+            </para>\r
+            <para>\r
+            NOTE: This appender writes each message to the <c>System.Console.Out</c> or \r
+            <c>System.Console.Error</c> that is set at the time the event is appended.\r
+            Therefore it is possible to programmatically redirect the output of this appender \r
+            (for example NUnit does this to capture program output). While this is the desired\r
+            behavior of this appender it may have security implications in your application. \r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleOut">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.ConsoleAppender.ConsoleError">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.ConsoleAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write \r
+            to the standard output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class\r
+            with the specified layout.\r
+            </summary>\r
+            <param name="layout">the layout to use for this appender</param>\r
+            <remarks>\r
+            The instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class is set up to write \r
+            to the standard output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ConsoleAppender.#ctor(log4net.Layout.ILayout,System.Boolean)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ConsoleAppender"/> class\r
+            with the specified layout.\r
+            </summary>\r
+            <param name="layout">the layout to use for this appender</param>\r
+            <param name="writeToErrorStream">flag set to <c>true</c> to write to the console error stream</param>\r
+            <remarks>\r
+            When <paramref name="writeToErrorStream"/> is set to <c>true</c>, output is written to\r
+            the standard error output stream.  Otherwise, output is written to the standard\r
+            output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ConsoleAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the event to the console.\r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ConsoleAppender.Target">\r
+            <summary>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </summary>\r
+            <value>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ConsoleAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.DebugAppender">\r
+            <summary>\r
+            Appends log events to the <see cref="T:System.Diagnostics.Debug"/> system.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The application configuration file can be used to control what listeners \r
+            are actually used. See the MSDN documentation for the \r
+            <see cref="T:System.Diagnostics.Debug"/> class for details on configuring the\r
+            debug system.\r
+            </para>\r
+            <para>\r
+            Events are written using the <see cref="M:System.Diagnostics.Debug.Write(string,string)"/>\r
+            method. The event's logger name is passed as the value for the category name to the Write method.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.DebugAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.DebugAppender.#ctor(log4net.Layout.ILayout)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.DebugAppender"/> \r
+            with a specified layout.\r
+            </summary>\r
+            <param name="layout">The layout to use with this appender.</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.DebugAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the logging event to the <see cref="T:System.Diagnostics.Debug"/> system.\r
+            If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is <c>true</c> then the <see cref="M:System.Diagnostics.Debug.Flush"/>\r
+            is called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.DebugAppender.m_immediateFlush">\r
+            <summary>\r
+            Immediate flush means that the underlying writer or output stream\r
+            will be flushed at the end of each append operation.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Immediate flush is slower but ensures that each append request is \r
+            actually written. If <see cref="P:log4net.Appender.DebugAppender.ImmediateFlush"/> is set to\r
+            <c>false</c>, then there is a good chance that the last few\r
+            logs events are not actually written to persistent media if and\r
+            when the application crashes.\r
+            </para>\r
+            <para>\r
+            The default value is <c>true</c>.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.DebugAppender.ImmediateFlush">\r
+            <summary>\r
+            Gets or sets a value that indicates whether the appender will \r
+            flush at the end of each write.\r
+            </summary>\r
+            <remarks>\r
+            <para>The default behavior is to flush at the end of each \r
+            write. If the option is set to<c>false</c>, then the underlying \r
+            stream can defer writing to physical medium to a later time. \r
+            </para>\r
+            <para>\r
+            Avoiding the flush operation at the end of each append results \r
+            in a performance gain of 10 to 20 percent. However, there is safety\r
+            trade-off involved in skipping flushing. Indeed, when flushing is\r
+            skipped, then it is likely that the last few log events will not\r
+            be recorded on disk when the application exits. This is a high\r
+            price to pay even for a 20% performance gain.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.DebugAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.EventLogAppender">\r
+            <summary>\r
+            Writes events to the system event log.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The appender will fail if you try to write using an event source that doesn't exist unless it is running with local administrator privileges.\r
+            See also http://logging.apache.org/log4net/release/faq.html#trouble-EventLog\r
+            </para>\r
+            <para>\r
+            The <c>EventID</c> of the event log entry can be\r
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)\r
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </para>\r
+            <para>\r
+            The <c>Category</c> of the event log entry can be\r
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)\r
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </para>\r
+            <para>\r
+            There is a limit of 32K characters for an event log message\r
+            </para>\r
+            <para>\r
+            When configuring the EventLogAppender a mapping can be\r
+            specified to map a logging level to an event log entry type. For example:\r
+            </para>\r
+            <code lang="XML">\r
+            &lt;mapping&gt;\r
+               &lt;level value="ERROR" /&gt;\r
+               &lt;eventLogEntryType value="Error" /&gt;\r
+            &lt;/mapping&gt;\r
+            &lt;mapping&gt;\r
+               &lt;level value="DEBUG" /&gt;\r
+               &lt;eventLogEntryType value="Information" /&gt;\r
+            &lt;/mapping&gt;\r
+            </code>\r
+            <para>\r
+            The Level is the standard log4net logging level and eventLogEntryType can be any value\r
+            from the <see cref="T:System.Diagnostics.EventLogEntryType"/> enum, i.e.:\r
+            <list type="bullet">\r
+            <item><term>Error</term><description>an error event</description></item>\r
+            <item><term>Warning</term><description>a warning event</description></item>\r
+            <item><term>Information</term><description>an informational event</description></item>\r
+            </list>\r
+            </para>\r
+            </remarks>\r
+            <author>Aspi Havewala</author>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Thomas Voss</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.#ctor(log4net.Layout.ILayout)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.EventLogAppender"/> class\r
+            with the specified <see cref="T:log4net.Layout.ILayout"/>.\r
+            </summary>\r
+            <param name="layout">The <see cref="T:log4net.Layout.ILayout"/> to use with this appender.</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.AddMapping(log4net.Appender.EventLogAppender.Level2EventLogEntryType)">\r
+            <summary>\r
+            Add a mapping of level to <see cref="T:System.Diagnostics.EventLogEntryType"/> - done by the config file\r
+            </summary>\r
+            <param name="mapping">The mapping to add</param>\r
+            <remarks>\r
+            <para>\r
+            Add a <see cref="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType"/> mapping to this appender.\r
+            Each mapping defines the event log entry type for a level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.EventLogAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.CreateEventSource(System.String,System.String,System.String)">\r
+            <summary>\r
+            Create an event log source\r
+            </summary>\r
+            <remarks>\r
+            Uses different API calls under NET_2_0\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>\r
+            method. \r
+            </summary>\r
+            <param name="loggingEvent">the event to log</param>\r
+            <remarks>\r
+            <para>Writes the event to the system event log using the \r
+            <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>.</para>\r
+            \r
+            <para>If the event has an <c>EventID</c> property (see <see cref="P:log4net.Core.LoggingEvent.Properties"/>)\r
+            set then this integer will be used as the event log event id.</para>\r
+            \r
+            <para>\r
+            There is a limit of 32K characters for an event log message\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.GetEntryType(log4net.Core.Level)">\r
+            <summary>\r
+            Get the equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/>\r
+            </summary>\r
+            <param name="level">the Level to convert to an EventLogEntryType</param>\r
+            <returns>The equivalent <see cref="T:System.Diagnostics.EventLogEntryType"/> for a <see cref="T:log4net.Core.Level"/> <paramref name="level"/></returns>\r
+            <remarks>\r
+            Because there are fewer applicable <see cref="T:System.Diagnostics.EventLogEntryType"/>\r
+            values to use in logging levels than there are in the \r
+            <see cref="T:log4net.Core.Level"/> this is a one way mapping. There is\r
+            a loss of information during the conversion.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_logName">\r
+            <summary>\r
+            The log name is the section in the event logs where the messages\r
+            are stored.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_applicationName">\r
+            <summary>\r
+            Name of the application to use when logging.  This appears in the\r
+            application column of the event log named by <see cref="F:log4net.Appender.EventLogAppender.m_logName"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_machineName">\r
+            <summary>\r
+            The name of the machine which holds the event log. This is\r
+            currently only allowed to be '.' i.e. the current machine.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_levelMapping">\r
+            <summary>\r
+            Mapping from level object to EventLogEntryType\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_securityContext">\r
+            <summary>\r
+            The security context to use for privileged calls\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_eventId">\r
+            <summary>\r
+            The event ID to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.m_category">\r
+            <summary>\r
+            The event category to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.declaringType">\r
+            <summary>\r
+            The fully qualified type of the EventLogAppender class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_DEFAULT">\r
+            <summary>\r
+            The maximum size supported by default.\r
+            </summary>\r
+            <remarks>\r
+            http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx\r
+            The 32766 documented max size is two bytes shy of 32K (I'm assuming 32766 \r
+            may leave space for a two byte null terminator of #0#0). The 32766 max \r
+            length is what the .NET 4.0 source code checks for, but this is WRONG! \r
+            Strings with a length > 31839 on Windows Vista or higher can CORRUPT \r
+            the event log! See: System.Diagnostics.EventLogInternal.InternalWriteEvent() \r
+            for the use of the 32766 max size.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE_VISTA_OR_NEWER">\r
+            <summary>\r
+            The maximum size supported by a windows operating system that is vista\r
+            or newer.\r
+            </summary>\r
+            <remarks>\r
+            See ReportEvent API:\r
+               http://msdn.microsoft.com/en-us/library/aa363679(VS.85).aspx\r
+            ReportEvent's lpStrings parameter:\r
+            "A pointer to a buffer containing an array of \r
+            null-terminated strings that are merged into the message before Event Viewer \r
+            displays the string to the user. This parameter must be a valid pointer \r
+            (or NULL), even if wNumStrings is zero. Each string is limited to 31,839 characters."\r
+            \r
+            Going beyond the size of 31839 will (at some point) corrupt the event log on Windows\r
+            Vista or higher! It may succeed for a while...but you will eventually run into the\r
+            error: "System.ComponentModel.Win32Exception : A device attached to the system is\r
+            not functioning", and the event log will then be corrupt (I was able to corrupt \r
+            an event log using a length of 31877 on Windows 7).\r
+            \r
+            The max size for Windows Vista or higher is documented here:\r
+               http://msdn.microsoft.com/en-us/library/xzwc042w(v=vs.100).aspx.\r
+            Going over this size may succeed a few times but the buffer will overrun and \r
+            eventually corrupt the log (based on testing).\r
+            \r
+            The maxEventMsgSize size is based on the max buffer size of the lpStrings parameter of the ReportEvent API.\r
+            The documented max size for EventLog.WriteEntry for Windows Vista and higher is 31839, but I'm leaving room for a\r
+            terminator of #0#0, as we cannot see the source of ReportEvent (though we could use an API monitor to examine the\r
+            buffer, given enough time).\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.EventLogAppender.MAX_EVENTLOG_MESSAGE_SIZE">\r
+            <summary>\r
+            The maximum size that the operating system supports for\r
+            a event log message.\r
+            </summary>\r
+            <remarks>\r
+            Used to determine the maximum string length that can be written\r
+            to the operating system event log and eventually truncate a string\r
+            that exceeds the limits.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.EventLogAppender.GetMaxEventLogMessageSize">\r
+            <summary>\r
+            This method determines the maximum event log message size allowed for\r
+            the current environment.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.LogName">\r
+            <summary>\r
+            The name of the log where messages will be stored.\r
+            </summary>\r
+            <value>\r
+            The string name of the log where messages will be stored.\r
+            </value>\r
+            <remarks>\r
+            <para>This is the name of the log as it appears in the Event Viewer\r
+            tree. The default value is to log into the <c>Application</c>\r
+            log, this is where most applications write their events. However\r
+            if you need a separate log for your application (or applications)\r
+            then you should set the <see cref="P:log4net.Appender.EventLogAppender.LogName"/> appropriately.</para>\r
+            <para>This should not be used to distinguish your event log messages\r
+            from those of other applications, the <see cref="P:log4net.Appender.EventLogAppender.ApplicationName"/>\r
+            property should be used to distinguish events. This property should be \r
+            used to group together events into a single log.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.ApplicationName">\r
+            <summary>\r
+            Property used to set the Application name.  This appears in the\r
+            event logs when logging.\r
+            </summary>\r
+            <value>\r
+            The string used to distinguish events from different sources.\r
+            </value>\r
+            <remarks>\r
+            Sets the event log source property.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.MachineName">\r
+            <summary>\r
+            This property is used to return the name of the computer to use\r
+            when accessing the event logs.  Currently, this is the current\r
+            computer, denoted by a dot "."\r
+            </summary>\r
+            <value>\r
+            The string name of the machine holding the event log that \r
+            will be logged into.\r
+            </value>\r
+            <remarks>\r
+            This property cannot be changed. It is currently set to '.'\r
+            i.e. the local machine. This may be changed in future.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.SecurityContext">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> used to write to the EventLog.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The system security context used to write to the EventLog.\r
+            </para>\r
+            <para>\r
+            Unless a <see cref="P:log4net.Appender.EventLogAppender.SecurityContext"/> specified here for this appender\r
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the\r
+            security context to use. The default behavior is to use the security context\r
+            of the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.EventId">\r
+            <summary>\r
+            Gets or sets the <c>EventId</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>EventID</c> of the event log entry will normally be\r
+            set using the <c>EventID</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)\r
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            This property provides the fallback value which defaults to 0.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.Category">\r
+            <summary>\r
+            Gets or sets the <c>Category</c> to use unless one is explicitly specified via the <c>LoggingEvent</c>'s properties.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>Category</c> of the event log entry will normally be\r
+            set using the <c>Category</c> property (<see cref="P:log4net.Core.LoggingEvent.Properties"/>)\r
+            on the <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            This property provides the fallback value which defaults to 0.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.EventLogAppender.Level2EventLogEntryType">\r
+            <summary>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the color it should be displayed as.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defines the mapping between a level and its event log entry type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The <see cref="P:log4net.Appender.EventLogAppender.Level2EventLogEntryType.EventLogEntryType"/> for this entry\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.FileAppender">\r
+            <summary>\r
+            Appends logging events to a file.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Logging events are sent to the file specified by\r
+            the <see cref="P:log4net.Appender.FileAppender.File"/> property.\r
+            </para>\r
+            <para>\r
+            The file can be opened in either append or overwrite mode \r
+            by specifying the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property.\r
+            If the file path is relative it is taken as relative from \r
+            the application base directory. The file encoding can be\r
+            specified by setting the <see cref="P:log4net.Appender.FileAppender.Encoding"/> property.\r
+            </para>\r
+            <para>\r
+            The layout's <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>\r
+            values will be written each time the file is opened and closed\r
+            respectively. If the <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is <see langword="true"/>\r
+            then the file may contain multiple copies of the header and footer.\r
+            </para>\r
+            <para>\r
+            This appender will first try to open the file for writing when <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/>\r
+            is called. This will typically be during configuration.\r
+            If the file cannot be opened for writing the appender will attempt\r
+            to open the file again each time a message is logged to the appender.\r
+            If the file cannot be opened for writing when a message is logged then\r
+            the message will be discarded by this appender.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Appender.FileAppender"/> supports pluggable file locking models via\r
+            the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> property.\r
+            The default behavior, implemented by <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> \r
+            is to obtain an exclusive write lock on the file until this appender is closed.\r
+            The alternative models only hold a\r
+            write lock while the appender is writing a logging event (<see cref="T:log4net.Appender.FileAppender.MinimalLock"/>)\r
+            or synchronize by using a named system wide Mutex (<see cref="T:log4net.Appender.FileAppender.InterProcessLock"/>).\r
+            </para>\r
+            <para>\r
+            All locking strategies have issues and you should seriously consider using a different strategy that\r
+            avoids having multiple processes logging to the same file.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Rodrigo B. de Oliveira</author>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Niall Daley</author>\r
+        </member>\r
+        <member name="T:log4net.Appender.TextWriterAppender">\r
+            <summary>\r
+            Sends logging events to a <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            An Appender that writes to a <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            <para>\r
+            This appender may be used stand alone if initialized with an appropriate\r
+            writer, however it is typically used as a base class for an appender that\r
+            can open a <see cref="T:System.IO.TextWriter"/> to write to.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Douglas de la Torre</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.Stream)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and\r
+            sets the output destination to a new <see cref="T:System.IO.StreamWriter"/> initialized \r
+            with the specified <see cref="T:System.IO.Stream"/>.\r
+            </summary>\r
+            <param name="layout">The layout to use with this appender.</param>\r
+            <param name="os">The <see cref="T:System.IO.Stream"/> to output to.</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.#ctor(log4net.Layout.ILayout,System.IO.TextWriter)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.TextWriterAppender"/> class and sets\r
+            the output destination to the specified <see cref="T:System.IO.StreamWriter"/>.\r
+            </summary>\r
+            <param name="layout">The layout to use with this appender</param>\r
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to output to</param>\r
+            <remarks>\r
+            The <see cref="T:System.IO.TextWriter"/> must have been previously opened.\r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.PreAppendCheck">\r
+            <summary>\r
+            This method determines if there is a sense in attempting to append.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method checks if an output target has been set and if a\r
+            layout has been set. \r
+            </para>\r
+            </remarks>\r
+            <returns><c>false</c> if any of the preconditions fail.</returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>\r
+            method. \r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a log statement to the output stream if the output stream exists \r
+            and is writable.  \r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.Append(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>\r
+            method. \r
+            </summary>\r
+            <param name="loggingEvents">The array of events to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method writes all the bulk logged events to the output writer\r
+            before flushing the stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.OnClose">\r
+            <summary>\r
+            Close this appender instance. The underlying stream or writer is also closed.\r
+            </summary>\r
+            <remarks>\r
+            Closed appenders cannot be reused.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooterAndCloseWriter">\r
+            <summary>\r
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the footer and closes the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.CloseWriter">\r
+            <summary>\r
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.Reset">\r
+            <summary>\r
+            Clears internal references to the underlying <see cref="T:System.IO.TextWriter"/> \r
+            and other variables.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Subclasses can override this method for an alternate closing behavior.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.WriteFooter">\r
+            <summary>\r
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.WriteHeader">\r
+            <summary>\r
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TextWriterAppender.PrepareWriter">\r
+            <summary>\r
+            Called to allow a subclass to lazily initialize the writer\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method is called when an event is logged and the <see cref="P:log4net.Appender.TextWriterAppender.Writer"/> or\r
+            <see cref="P:log4net.Appender.TextWriterAppender.QuietWriter"/> have not been set. This allows a subclass to\r
+            attempt to initialize the writer multiple times.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.TextWriterAppender.m_qtw">\r
+            <summary>\r
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events\r
+            will be written to. \r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.TextWriterAppender.m_immediateFlush">\r
+            <summary>\r
+            Immediate flush means that the underlying <see cref="T:System.IO.TextWriter"/> \r
+            or output stream will be flushed at the end of each append operation.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Immediate flush is slower but ensures that each append request is \r
+            actually written. If <see cref="P:log4net.Appender.TextWriterAppender.ImmediateFlush"/> is set to\r
+            <c>false</c>, then there is a good chance that the last few\r
+            logging events are not actually persisted if and when the application \r
+            crashes.\r
+            </para>\r
+            <para>\r
+            The default value is <c>true</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.TextWriterAppender.declaringType">\r
+            <summary>\r
+            The fully qualified type of the TextWriterAppender class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TextWriterAppender.ImmediateFlush">\r
+            <summary>\r
+            Gets or set whether the appender will flush at the end \r
+            of each append operation.\r
+            </summary>\r
+            <value>\r
+            <para>\r
+            The default behavior is to flush at the end of each \r
+            append operation.\r
+            </para>\r
+            <para>\r
+            If this option is set to <c>false</c>, then the underlying \r
+            stream can defer persisting the logging event to a later \r
+            time.\r
+            </para>\r
+            </value>\r
+            <remarks>\r
+            Avoiding the flush operation at the end of each append results in\r
+            a performance gain of 10 to 20 percent. However, there is safety\r
+            trade-off involved in skipping flushing. Indeed, when flushing is\r
+            skipped, then it is likely that the last few log events will not\r
+            be recorded on disk when the application exits. This is a high\r
+            price to pay even for a 20% performance gain.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TextWriterAppender.Writer">\r
+            <summary>\r
+            Sets the <see cref="T:System.IO.TextWriter"/> where the log output will go.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The specified <see cref="T:System.IO.TextWriter"/> must be open and writable.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:System.IO.TextWriter"/> will be closed when the appender \r
+            instance is closed.\r
+            </para>\r
+            <para>\r
+            <b>Note:</b> Logging to an unopened <see cref="T:System.IO.TextWriter"/> will fail.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TextWriterAppender.ErrorHandler">\r
+            <summary>\r
+            Gets or set the <see cref="T:log4net.Core.IErrorHandler"/> and the underlying \r
+            <see cref="T:log4net.Util.QuietTextWriter"/>, if any, for this appender. \r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Core.IErrorHandler"/> for this appender.\r
+            </value>\r
+        </member>\r
+        <member name="P:log4net.Appender.TextWriterAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TextWriterAppender.QuietWriter">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events\r
+            will be written to. \r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Util.QuietTextWriter"/> where logging events are written.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This is the <see cref="T:log4net.Util.QuietTextWriter"/> where logging events\r
+            will be written to. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String,System.Boolean)">\r
+            <summary>\r
+            Construct a new appender using the layout, file and append mode.\r
+            </summary>\r
+            <param name="layout">the layout to use with this appender</param>\r
+            <param name="filename">the full path to the file to write to</param>\r
+            <param name="append">flag to indicate if the file should be appended to</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.#ctor(log4net.Layout.ILayout,System.String)">\r
+            <summary>\r
+            Construct a new appender using the layout and file specified.\r
+            The file will be appended to.\r
+            </summary>\r
+            <param name="layout">the layout to use with this appender</param>\r
+            <param name="filename">the full path to the file to write to</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.ActivateOptions">\r
+            <summary>\r
+            Activate the options on the file appender. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.FileAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            This will cause the file to be opened.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.Reset">\r
+            <summary>\r
+            Closes any previously opened file and calls the parent's <see cref="M:log4net.Appender.TextWriterAppender.Reset"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Resets the filename and the file stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.PrepareWriter">\r
+            <summary>\r
+            Called to initialize the file writer\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Will be called for each logged message until the file is\r
+            successfully opened.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/>\r
+            method. \r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a log statement to the output stream if the output stream exists \r
+            and is writable.  \r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.Append(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent[])"/>\r
+            method. \r
+            </summary>\r
+            <param name="loggingEvents">The array of events to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Acquires the output file locks once before writing all the events to\r
+            the stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.WriteFooter">\r
+            <summary>\r
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes a footer as produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Footer"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.WriteHeader">\r
+            <summary>\r
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes a header produced by the embedded layout's <see cref="P:log4net.Layout.ILayout.Header"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.CloseWriter">\r
+            <summary>\r
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Closes the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.CloseFile">\r
+            <summary>\r
+            Closes the previously opened file.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Layout.ILayout.Footer"/> to the file and then\r
+            closes the file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.SafeOpenFile(System.String,System.Boolean)">\r
+            <summary>\r
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.\r
+            </summary>\r
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>\r
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>\r
+            <remarks>\r
+            <para>\r
+            Calls <see cref="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)"/> but guarantees not to throw an exception.\r
+            Errors are passed to the <see cref="P:log4net.Appender.TextWriterAppender.ErrorHandler"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.OpenFile(System.String,System.Boolean)">\r
+            <summary>\r
+            Sets and <i>opens</i> the file where the log output will go. The specified file must be writable.\r
+            </summary>\r
+            <param name="fileName">The path to the log file. Must be a fully qualified path.</param>\r
+            <param name="append">If true will append to fileName. Otherwise will truncate fileName</param>\r
+            <remarks>\r
+            <para>\r
+            If there was already an opened file, then the previous file\r
+            is closed first.\r
+            </para>\r
+            <para>\r
+            This method will ensure that the directory structure\r
+            for the <paramref name="fileName"/> specified exists.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.Stream)">\r
+            <summary>\r
+            Sets the quiet writer used for file output\r
+            </summary>\r
+            <param name="fileStream">the file stream that has been opened for writing</param>\r
+            <remarks>\r
+            <para>\r
+            This implementation of <see cref="M:SetQWForFiles(Stream)"/> creates a <see cref="T:System.IO.StreamWriter"/>\r
+            over the <paramref name="fileStream"/> and passes it to the \r
+            <see cref="M:SetQWForFiles(TextWriter)"/> method.\r
+            </para>\r
+            <para>\r
+            This method can be overridden by sub classes that want to wrap the\r
+            <see cref="T:System.IO.Stream"/> in some way, for example to encrypt the output\r
+            data using a <c>System.Security.Cryptography.CryptoStream</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.SetQWForFiles(System.IO.TextWriter)">\r
+            <summary>\r
+            Sets the quiet writer being used.\r
+            </summary>\r
+            <param name="writer">the writer over the file stream that has been opened for writing</param>\r
+            <remarks>\r
+            <para>\r
+            This method can be overridden by sub classes that want to\r
+            wrap the <see cref="T:System.IO.TextWriter"/> in some way.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.ConvertToFullPath(System.String)">\r
+            <summary>\r
+            Convert a path into a fully qualified path.\r
+            </summary>\r
+            <param name="path">The path to convert.</param>\r
+            <returns>The fully qualified path.</returns>\r
+            <remarks>\r
+            <para>\r
+            Converts the path specified to a fully\r
+            qualified path. If the path is relative it is\r
+            taken as relative from the application base \r
+            directory.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.m_appendToFile">\r
+            <summary>\r
+            Flag to indicate if we should append to the file\r
+            or overwrite the file. The default is to append.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.m_fileName">\r
+            <summary>\r
+            The name of the log file.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.m_encoding">\r
+            <summary>\r
+            The encoding to use for the file stream.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.m_securityContext">\r
+            <summary>\r
+            The security context to use for privileged calls\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.m_stream">\r
+            <summary>\r
+            The stream to log to. Has added locking semantics\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.m_lockingModel">\r
+            <summary>\r
+            The locking model to use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.FileAppender.declaringType">\r
+            <summary>\r
+            The fully qualified type of the FileAppender class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.FileAppender.File">\r
+            <summary>\r
+            Gets or sets the path to the file that logging will be written to.\r
+            </summary>\r
+            <value>\r
+            The path to the file that logging will be written to.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If the path is relative it is taken as relative from \r
+            the application base directory.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.FileAppender.AppendToFile">\r
+            <summary>\r
+            Gets or sets a flag that indicates whether the file should be\r
+            appended to or overwritten.\r
+            </summary>\r
+            <value>\r
+            Indicates whether the file should be appended to or overwritten.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If the value is set to false then the file will be overwritten, if \r
+            it is set to true then the file will be appended to.\r
+            </para>\r
+            The default value is true.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.FileAppender.Encoding">\r
+            <summary>\r
+            Gets or sets <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.FileAppender.Encoding"/> used to write to the file.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The default encoding set is <see cref="P:System.Text.Encoding.Default"/>\r
+            which is the encoding for the system's current ANSI code page.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.FileAppender.SecurityContext">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> used to write to the file.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Unless a <see cref="P:log4net.Appender.FileAppender.SecurityContext"/> specified here for this appender\r
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the\r
+            security context to use. The default behavior is to use the security context\r
+            of the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.FileAppender.LockingModel">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to lock the file.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the <see cref="P:log4net.Appender.FileAppender.LockingModel"/> used to handle locking of the file.\r
+            </para>\r
+            <para>\r
+            There are three built in locking models, <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>, <see cref="T:log4net.Appender.FileAppender.MinimalLock"/> and <see cref="T:log4net.Appender.FileAppender.InterProcessLock"/> .\r
+            The first locks the file from the start of logging to the end, the \r
+            second locks only for the minimal amount of time when logging each message\r
+            and the last synchronizes processes using a named system wide Mutex.\r
+            </para>\r
+            <para>\r
+            The default locking model is the <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.FileAppender.LockingStream">\r
+            <summary>\r
+            Write only <see cref="T:System.IO.Stream"/> that uses the <see cref="T:log4net.Appender.FileAppender.LockingModelBase"/> \r
+            to manage access to an underlying resource.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingStream.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">\r
+            <summary>\r
+            True asynchronous writes are not supported, the implementation forces a synchronous write.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.LogException">\r
+            <summary>\r
+            Exception base type for log4net.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This type extends <see cref="T:System.ApplicationException"/>. It\r
+            does not add any new functionality but does differentiate the\r
+            type of exception being thrown.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.LogException.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogException.#ctor(System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="message">A message to include with the exception.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class with\r
+            the specified message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogException.#ctor(System.String,System.Exception)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="message">A message to include with the exception.</param>\r
+            <param name="innerException">A nested exception to include.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class\r
+            with the specified message and inner exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization constructor\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>\r
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LogException"/> class \r
+            with serialized data.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.FileAppender.LockingModelBase">\r
+            <summary>\r
+            Locking model base class\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Base class for the locking models available to the <see cref="T:log4net.Appender.FileAppender"/> derived loggers.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)">\r
+            <summary>\r
+            Open the output file\r
+            </summary>\r
+            <param name="filename">The filename to use</param>\r
+            <param name="append">Whether to append to the file, or overwrite</param>\r
+            <param name="encoding">The encoding to use</param>\r
+            <remarks>\r
+            <para>\r
+            Open the file specified and prepare for logging. \r
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called.\r
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/>,\r
+            <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseFile">\r
+            <summary>\r
+            Close the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close the file. No further writes will be made.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock">\r
+            <summary>\r
+            Acquire the lock on the file\r
+            </summary>\r
+            <returns>A stream that is ready to be written to.</returns>\r
+            <remarks>\r
+            <para>\r
+            Acquire the lock on the file in preparation for writing to it. \r
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock"/>\r
+            must be called to release the lock on the output file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.ReleaseLock">\r
+            <summary>\r
+            Release the lock on the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Release the lock on the file. No further writes will be made to the \r
+            stream until <see cref="M:log4net.Appender.FileAppender.LockingModelBase.AcquireLock"/> is called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CreateStream(System.String,System.Boolean,System.IO.FileShare)">\r
+            <summary>\r
+            Helper method that creates a FileStream under CurrentAppender's SecurityContext.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Typically called during OpenFile or AcquireLock. \r
+            </para>\r
+            <para>\r
+            If the directory portion of the <paramref name="filename"/> does not exist, it is created\r
+            via Directory.CreateDirecctory.\r
+            </para>\r
+            </remarks>\r
+            <param name="filename"></param>\r
+            <param name="append"></param>\r
+            <param name="fileShare"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.LockingModelBase.CloseStream(System.IO.Stream)">\r
+            <summary>\r
+            Helper method to close <paramref name="stream"/> under CurrentAppender's SecurityContext.\r
+            </summary>\r
+            <remarks>\r
+            Does not set <paramref name="stream"/> to null.\r
+            </remarks>\r
+            <param name="stream"></param>\r
+        </member>\r
+        <member name="P:log4net.Appender.FileAppender.LockingModelBase.CurrentAppender">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Appender.FileAppender"/> for this LockingModel\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The file appender this locking model is attached to and working on\r
+            behalf of.\r
+            </para>\r
+            <para>\r
+            The file appender is used to locate the security context and the error handler to use.\r
+            </para>\r
+            <para>\r
+            The value of this property will be set before <see cref="M:log4net.Appender.FileAppender.LockingModelBase.OpenFile(System.String,System.Boolean,System.Text.Encoding)"/> is\r
+            called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.FileAppender.ExclusiveLock">\r
+            <summary>\r
+            Hold an exclusive lock on the output file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Open the file once for writing and hold it open until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/> is called. \r
+            Maintains an exclusive lock on the file during this time.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">\r
+            <summary>\r
+            Open the file specified and prepare for logging.\r
+            </summary>\r
+            <param name="filename">The filename to use</param>\r
+            <param name="append">Whether to append to the file, or overwrite</param>\r
+            <param name="encoding">The encoding to use</param>\r
+            <remarks>\r
+            <para>\r
+            Open the file specified and prepare for logging. \r
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/> is called.\r
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock"/>,\r
+            <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.CloseFile">\r
+            <summary>\r
+            Close the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close the file. No further writes will be made.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.AcquireLock">\r
+            <summary>\r
+            Acquire the lock on the file\r
+            </summary>\r
+            <returns>A stream that is ready to be written to.</returns>\r
+            <remarks>\r
+            <para>\r
+            Does nothing. The lock is already taken\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.ExclusiveLock.ReleaseLock">\r
+            <summary>\r
+            Release the lock on the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Does nothing. The lock will be released when the file is closed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.FileAppender.MinimalLock">\r
+            <summary>\r
+            Acquires the file lock for each write\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Opens the file once for each <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>/<see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> cycle, \r
+            thus holding the lock for the minimal amount of time. This method of locking\r
+            is considerably slower than <see cref="T:log4net.Appender.FileAppender.ExclusiveLock"/> but allows \r
+            other processes to move/delete the log file whilst logging continues.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">\r
+            <summary>\r
+            Prepares to open the file when the first message is logged.\r
+            </summary>\r
+            <param name="filename">The filename to use</param>\r
+            <param name="append">Whether to append to the file, or overwrite</param>\r
+            <param name="encoding">The encoding to use</param>\r
+            <remarks>\r
+            <para>\r
+            Open the file specified and prepare for logging. \r
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called.\r
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/>,\r
+            <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.MinimalLock.CloseFile"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.CloseFile">\r
+            <summary>\r
+            Close the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close the file. No further writes will be made.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock">\r
+            <summary>\r
+            Acquire the lock on the file\r
+            </summary>\r
+            <returns>A stream that is ready to be written to.</returns>\r
+            <remarks>\r
+            <para>\r
+            Acquire the lock on the file in preparation for writing to it. \r
+            Return a stream pointing to the file. <see cref="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock"/>\r
+            must be called to release the lock on the output file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.MinimalLock.ReleaseLock">\r
+            <summary>\r
+            Release the lock on the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Release the lock on the file. No further writes will be made to the \r
+            stream until <see cref="M:log4net.Appender.FileAppender.MinimalLock.AcquireLock"/> is called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.FileAppender.InterProcessLock">\r
+            <summary>\r
+            Provides cross-process file locking.\r
+            </summary>\r
+            <author>Ron Grabowski</author>\r
+            <author>Steve Wranovsky</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.OpenFile(System.String,System.Boolean,System.Text.Encoding)">\r
+            <summary>\r
+            Open the file specified and prepare for logging.\r
+            </summary>\r
+            <param name="filename">The filename to use</param>\r
+            <param name="append">Whether to append to the file, or overwrite</param>\r
+            <param name="encoding">The encoding to use</param>\r
+            <remarks>\r
+            <para>\r
+            Open the file specified and prepare for logging. \r
+            No writes will be made until <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/> is called.\r
+            Must be called before any calls to <see cref="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock"/>,\r
+            -<see cref="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock"/> and <see cref="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.CloseFile">\r
+            <summary>\r
+            Close the file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close the file. No further writes will be made.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.AcquireLock">\r
+            <summary>\r
+            Acquire the lock on the file\r
+            </summary>\r
+            <returns>A stream that is ready to be written to.</returns>\r
+            <remarks>\r
+            <para>\r
+            Does nothing. The lock is already taken\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.FileAppender.InterProcessLock.ReleaseLock">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.ForwardingAppender">\r
+            <summary>\r
+            This appender forwards logging events to attached appenders.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The forwarding appender can be used to specify different thresholds\r
+            and filters for the same appender at different locations within the hierarchy.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ForwardingAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.OnClose">\r
+            <summary>\r
+            Closes the appender and releases resources.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Releases any resources allocated within the appender such as file handles, \r
+            network connections, etc.\r
+            </para>\r
+            <para>\r
+            It is a programming error to append to a closed appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Forward the logging event to the attached appenders \r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Delivers the logging event to all the attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.Append(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Forward the logging events to the attached appenders \r
+            </summary>\r
+            <param name="loggingEvents">The array of events to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Delivers the logging events to all the attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.AddAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Adds an <see cref="T:log4net.Appender.IAppender"/> to the list of appenders of this\r
+            instance.\r
+            </summary>\r
+            <param name="newAppender">The <see cref="T:log4net.Appender.IAppender"/> to add to this appender.</param>\r
+            <remarks>\r
+            <para>\r
+            If the specified <see cref="T:log4net.Appender.IAppender"/> is already in the list of\r
+            appenders, then it won't be added again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.GetAppender(System.String)">\r
+            <summary>\r
+            Looks for the appender with the specified name.\r
+            </summary>\r
+            <param name="name">The name of the appender to lookup.</param>\r
+            <returns>\r
+            The appender with the specified name, or <c>null</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Get the named appender attached to this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAllAppenders">\r
+            <summary>\r
+            Removes all previously added appenders from this appender.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is useful when re-reading configuration information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Removes the specified appender from the list of appenders.\r
+            </summary>\r
+            <param name="appender">The appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ForwardingAppender.RemoveAppender(System.String)">\r
+            <summary>\r
+            Removes the appender with the specified name from the list of appenders.\r
+            </summary>\r
+            <param name="name">The name of the appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.ForwardingAppender.m_appenderAttachedImpl">\r
+            <summary>\r
+            Implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.ForwardingAppender.Appenders">\r
+            <summary>\r
+            Gets the appenders contained in this appender as an \r
+            <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <remarks>\r
+            If no appenders can be found, then an <see cref="T:log4net.Util.EmptyCollection"/> \r
+            is returned.\r
+            </remarks>\r
+            <returns>\r
+            A collection of the appenders in this appender.\r
+            </returns>\r
+        </member>\r
+        <member name="T:log4net.Appender.LocalSyslogAppender">\r
+            <summary>\r
+            Logs events to a local syslog service.\r
+            </summary>\r
+            <remarks>\r
+            <note>\r
+            This appender uses the POSIX libc library functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c>.\r
+            If these functions are not available on the local system then this appender will not work!\r
+            </note>\r
+            <para>\r
+            The functions <c>openlog</c>, <c>syslog</c>, and <c>closelog</c> are specified in SUSv2 and \r
+            POSIX 1003.1-2001 standards. These are used to log messages to the local syslog service.\r
+            </para>\r
+            <para>\r
+            This appender talks to a local syslog service. If you need to log to a remote syslog\r
+            daemon and you cannot configure your local syslog service to do this you may be\r
+            able to use the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> to log via UDP.\r
+            </para>\r
+            <para>\r
+            Syslog messages must have a facility and and a severity. The severity\r
+            is derived from the Level of the logging event.\r
+            The facility must be chosen from the set of defined syslog \r
+            <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The facilities list is predefined\r
+            and cannot be extended.\r
+            </para>\r
+            <para>\r
+            An identifier is specified with each log message. This can be specified\r
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know \r
+            as the tag) must not contain white space. The default value for the\r
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).\r
+            </para>\r
+            </remarks>\r
+            <author>Rob Lyon</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            This instance of the <see cref="T:log4net.Appender.LocalSyslogAppender"/> class is set up to write \r
+            to a local syslog service.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)">\r
+            <summary>\r
+            Add a mapping of level to severity\r
+            </summary>\r
+            <param name="mapping">The mapping to add</param>\r
+            <remarks>\r
+            <para>\r
+            Adds a <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/> to this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.LocalSyslogAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the event to a remote syslog daemon.\r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.OnClose">\r
+            <summary>\r
+            Close the syslog when the appender is closed\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close the syslog when the appender is closed\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.GetSeverity(log4net.Core.Level)">\r
+            <summary>\r
+            Translates a log4net level to a syslog severity.\r
+            </summary>\r
+            <param name="level">A log4net level.</param>\r
+            <returns>A syslog severity.</returns>\r
+            <remarks>\r
+            <para>\r
+            Translates a log4net level to a syslog severity.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.GeneratePriority(log4net.Appender.LocalSyslogAppender.SyslogFacility,log4net.Appender.LocalSyslogAppender.SyslogSeverity)">\r
+            <summary>\r
+            Generate a syslog priority.\r
+            </summary>\r
+            <param name="facility">The syslog facility.</param>\r
+            <param name="severity">The syslog severity.</param>\r
+            <returns>A syslog priority.</returns>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_facility">\r
+            <summary>\r
+            The facility. The default facility is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_identity">\r
+            <summary>\r
+            The message identity\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_handleToIdentity">\r
+            <summary>\r
+            Marshaled handle to the identity string. We have to hold on to the\r
+            string as the <c>openlog</c> and <c>syslog</c> APIs just hold the\r
+            pointer to the ident and dereference it for each log message.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.m_levelMapping">\r
+            <summary>\r
+            Mapping from level object to syslog severity\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.openlog(System.IntPtr,System.Int32,log4net.Appender.LocalSyslogAppender.SyslogFacility)">\r
+            <summary>\r
+            Open connection to system logger.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.syslog(System.Int32,System.String,System.String)">\r
+            <summary>\r
+            Generate a log message.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The libc syslog method takes a format string and a variable argument list similar\r
+            to the classic printf function. As this type of vararg list is not supported\r
+            by C# we need to specify the arguments explicitly. Here we have specified the\r
+            format string with a single message argument. The caller must set the format \r
+            string to <c>"%s"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.LocalSyslogAppender.closelog">\r
+            <summary>\r
+            Close descriptor used to write to system logger.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.LocalSyslogAppender.Identity">\r
+            <summary>\r
+            Message identity\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            An identifier is specified with each log message. This can be specified\r
+            by setting the <see cref="P:log4net.Appender.LocalSyslogAppender.Identity"/> property. The identity (also know \r
+            as the tag) must not contain white space. The default value for the\r
+            identity is the application name (from <see cref="P:log4net.Util.SystemInfo.ApplicationFriendlyName"/>).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.LocalSyslogAppender.Facility">\r
+            <summary>\r
+            Syslog facility\r
+            </summary>\r
+            <remarks>\r
+            Set to one of the <see cref="T:log4net.Appender.LocalSyslogAppender.SyslogFacility"/> values. The list of\r
+            facilities is predefined and cannot be extended. The default value\r
+            is <see cref="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User"/>.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.LocalSyslogAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogSeverity">\r
+            <summary>\r
+            syslog severities\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The log4net Level maps to a syslog severity using the\r
+            <see cref="M:log4net.Appender.LocalSyslogAppender.AddMapping(log4net.Appender.LocalSyslogAppender.LevelSeverity)"/> method and the <see cref="T:log4net.Appender.LocalSyslogAppender.LevelSeverity"/>\r
+            class. The severity is set on <see cref="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Emergency">\r
+            <summary>\r
+            system is unusable\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Alert">\r
+            <summary>\r
+            action must be taken immediately\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Critical">\r
+            <summary>\r
+            critical conditions\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Error">\r
+            <summary>\r
+            error conditions\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Warning">\r
+            <summary>\r
+            warning conditions\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Notice">\r
+            <summary>\r
+            normal but significant condition\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Informational">\r
+            <summary>\r
+            informational\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogSeverity.Debug">\r
+            <summary>\r
+            debug-level messages\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.LocalSyslogAppender.SyslogFacility">\r
+            <summary>\r
+            syslog facilities\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The syslog facility defines which subsystem the logging comes from.\r
+            This is set on the <see cref="P:log4net.Appender.LocalSyslogAppender.Facility"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Kernel">\r
+            <summary>\r
+            kernel messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.User">\r
+            <summary>\r
+            random user-level messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Mail">\r
+            <summary>\r
+            mail system\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Daemons">\r
+            <summary>\r
+            system daemons\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization">\r
+            <summary>\r
+            security/authorization messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Syslog">\r
+            <summary>\r
+            messages generated internally by syslogd\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Printer">\r
+            <summary>\r
+            line printer subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.News">\r
+            <summary>\r
+            network news subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Uucp">\r
+            <summary>\r
+            UUCP subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock">\r
+            <summary>\r
+            clock (cron/at) daemon\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Authorization2">\r
+            <summary>\r
+            security/authorization  messages (private)\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ftp">\r
+            <summary>\r
+            ftp daemon\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Ntp">\r
+            <summary>\r
+            NTP subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Audit">\r
+            <summary>\r
+            log audit\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Alert">\r
+            <summary>\r
+            log alert\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Clock2">\r
+            <summary>\r
+            clock daemon\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local0">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local1">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local2">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local3">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local4">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local5">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local6">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.LocalSyslogAppender.SyslogFacility.Local7">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.LocalSyslogAppender.LevelSeverity">\r
+            <summary>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the syslog severity that is should be logged at.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the syslog severity that is should be logged at.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.LocalSyslogAppender.LevelSeverity.Severity">\r
+            <summary>\r
+            The mapped syslog severity for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped syslog severity for the specified level\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender">\r
+            <summary>\r
+            Appends colorful logging events to the console, using the .NET 2\r
+            built-in capabilities.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            ManagedColoredConsoleAppender appends log events to the standard output stream\r
+            or the error output stream using a layout specified by the \r
+            user. It also allows the color of a specific type of message to be set.\r
+            </para>\r
+            <para>\r
+            By default, all output is written to the console's standard output stream.\r
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> property can be set to direct the output to the\r
+            error stream.\r
+            </para>\r
+            <para>\r
+            When configuring the colored console appender, mappings should be\r
+            specified to map logging levels to colors. For example:\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <mapping>\r
+               <level value="ERROR"/>\r
+               <foreColor value="DarkRed"/>\r
+               <backColor value="White"/>\r
+            </mapping>\r
+            <mapping>\r
+               <level value="WARN"/>\r
+               <foreColor value="Yellow"/>\r
+            </mapping>\r
+            <mapping>\r
+               <level value="INFO"/>\r
+               <foreColor value="White"/>\r
+            </mapping>\r
+            <mapping>\r
+               <level value="DEBUG"/>\r
+               <foreColor value="Blue"/>\r
+            </mapping>\r
+            </code>\r
+            <para>\r
+            The Level is the standard log4net logging level while\r
+            ForeColor and BackColor are the values of <see cref="T:System.ConsoleColor"/>\r
+            enumeration.\r
+            </para>\r
+            <para>\r
+            Based on the ColoredConsoleAppender\r
+            </para>\r
+            </remarks>\r
+            <author>Rick Hobbs</author>\r
+            <author>Nicko Cadell</author>\r
+            <author>Pavlos Touboulidis</author>\r
+        </member>\r
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleOut">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.ConsoleError">\r
+            <summary>\r
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.ManagedColoredConsoleAppender.Target"/> to use when writing to the Console \r
+            standard error output stream.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            The instance of the <see cref="T:log4net.Appender.ManagedColoredConsoleAppender"/> class is set up to write \r
+            to the standard output stream.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.AddMapping(log4net.Appender.ManagedColoredConsoleAppender.LevelColors)">\r
+            <summary>\r
+            Add a mapping of level to color - done by the config file\r
+            </summary>\r
+            <param name="mapping">The mapping to add</param>\r
+            <remarks>\r
+            <para>\r
+            Add a <see cref="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors"/> mapping to this appender.\r
+            Each mapping defines the foreground and background colors\r
+            for a level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the event to the console.\r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.ManagedColoredConsoleAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the options for this appender\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initialize the level to color mappings set on this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_writeToErrorStream">\r
+            <summary>\r
+            Flag to write output to the error stream rather than the standard output stream\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.ManagedColoredConsoleAppender.m_levelMapping">\r
+            <summary>\r
+            Mapping from level object to color value\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.Target">\r
+            <summary>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </summary>\r
+            <value>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Target is the value of the console output stream.\r
+            This is either <c>"Console.Out"</c> or <c>"Console.Error"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.ManagedColoredConsoleAppender.LevelColors">\r
+            <summary>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the color it should be displayed as.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defines the mapping between a level and the color it should be displayed in.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.ForeColor">\r
+            <summary>\r
+            The mapped foreground color for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped foreground color for the specified level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.ManagedColoredConsoleAppender.LevelColors.BackColor">\r
+            <summary>\r
+            The mapped background color for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped background color for the specified level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.MemoryAppender">\r
+            <summary>\r
+            Stores logging events in an array.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The memory appender stores all the logging events\r
+            that are appended in an in-memory array.\r
+            </para>\r
+            <para>\r
+            Use the <see cref="M:log4net.Appender.MemoryAppender.GetEvents"/> method to get\r
+            the current list of events that have been appended.\r
+            </para>\r
+            <para>\r
+            Use the <see cref="M:Clear()"/> method to clear the\r
+            current list of events.\r
+            </para>\r
+            </remarks>\r
+            <author>Julian Biddle</author>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.MemoryAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.MemoryAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.MemoryAppender.GetEvents">\r
+            <summary>\r
+            Gets the events that have been logged.\r
+            </summary>\r
+            <returns>The events that have been logged</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the events that have been logged.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.MemoryAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method. \r
+            </summary>\r
+            <param name="loggingEvent">the event to log</param>\r
+            <remarks>\r
+            <para>Stores the <paramref name="loggingEvent"/> in the events list.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.MemoryAppender.Clear">\r
+            <summary>\r
+            Clear the list of events\r
+            </summary>\r
+            <remarks>\r
+            Clear the list of events\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.MemoryAppender.m_eventsList">\r
+            <summary>\r
+            The list of events that have been appended.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.MemoryAppender.m_fixFlags">\r
+            <summary>\r
+            Value indicating which fields in the event should be fixed\r
+            </summary>\r
+            <remarks>\r
+            By default all fields are fixed\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.MemoryAppender.OnlyFixPartialEventData">\r
+            <summary>\r
+            Gets or sets a value indicating whether only part of the logging event \r
+            data should be fixed.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if the appender should only fix part of the logging event \r
+            data, otherwise <c>false</c>. The default is <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Setting this property to <c>true</c> will cause only part of the event \r
+            data to be fixed and stored in the appender, hereby improving performance. \r
+            </para>\r
+            <para>\r
+            See <see cref="M:LoggingEvent.FixVolatileData(bool)"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.MemoryAppender.Fix">\r
+            <summary>\r
+            Gets or sets the fields that will be fixed in the event\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The logging event needs to have certain thread specific values \r
+            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>\r
+            for details.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.NetSendAppender">\r
+            <summary>\r
+            Logs entries by sending network messages using the \r
+            <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> native function.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            You can send messages only to names that are active \r
+            on the network. If you send the message to a user name, \r
+            that user must be logged on and running the Messenger \r
+            service to receive the message.\r
+            </para>\r
+            <para>\r
+            The receiver will get a top most window displaying the \r
+            messages one at a time, therefore this appender should \r
+            not be used to deliver a high volume of messages.\r
+            </para>\r
+            <para>\r
+            The following table lists some possible uses for this appender :\r
+            </para>\r
+            <para>\r
+            <list type="table">\r
+                <listheader>\r
+                    <term>Action</term>\r
+                    <description>Property Value(s)</description>\r
+                </listheader>\r
+                <item>\r
+                    <term>Send a message to a user account on the local machine</term>\r
+                    <description>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine&gt;\r
+                        </para>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>Send a message to a user account on a remote machine</term>\r
+                    <description>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the remote machine&gt;\r
+                        </para>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>Send a message to a domain user account</term>\r
+                    <description>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of a domain controller | uninitialized&gt;\r
+                        </para>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;user name&gt;\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>Send a message to all the names in a workgroup or domain</term>\r
+                    <description>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;workgroup name | domain name&gt;*\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>Send a message from the local machine to a remote machine</term>\r
+                    <description>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Server"/> = &lt;name of the local machine | uninitialized&gt;\r
+                        </para>\r
+                        <para>\r
+                        <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> = &lt;name of the remote machine&gt;\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            <b>Note :</b> security restrictions apply for sending \r
+            network messages, see <see cref="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)"/> \r
+            for more information.\r
+            </para>\r
+            </remarks>\r
+            <example>\r
+            <para>\r
+            An example configuration section to log information \r
+            using this appender from the local machine, named \r
+            LOCAL_PC, to machine OPERATOR_PC :\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <appender name="NetSendAppender_Operator" type="log4net.Appender.NetSendAppender">\r
+                <server value="LOCAL_PC"/>\r
+                <recipient value="OPERATOR_PC"/>\r
+                <layout type="log4net.Layout.PatternLayout" value="%-5p %c [%x] - %m%n"/>\r
+            </appender>\r
+            </code>\r
+            </example>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Appender.NetSendAppender.m_server">\r
+            <summary>\r
+            The DNS or NetBIOS name of the server on which the function is to execute.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.NetSendAppender.m_sender">\r
+            <summary>\r
+            The sender of the network message.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.NetSendAppender.m_recipient">\r
+            <summary>\r
+            The message alias to which the message should be sent.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.NetSendAppender.m_securityContext">\r
+            <summary>\r
+            The security context to use for privileged calls\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.NetSendAppender.#ctor">\r
+            <summary>\r
+            Initializes the appender.\r
+            </summary>\r
+            <remarks>\r
+            The default constructor initializes all fields to their default values.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.NetSendAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.NetSendAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            The appender will be ignored if no <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was specified.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.NetSendAppender.Recipient"/> was not specified.</exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.NetSendAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Sends the event using a network message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.NetSendAppender.NetMessageBufferSend(System.String,System.String,System.String,System.String,System.Int32)">\r
+            <summary>\r
+            Sends a buffer of information to a registered message alias.\r
+            </summary>\r
+            <param name="serverName">The DNS or NetBIOS name of the server on which the function is to execute.</param>\r
+            <param name="msgName">The message alias to which the message buffer should be sent</param>\r
+            <param name="fromName">The originator of the message.</param>\r
+            <param name="buffer">The message text.</param>\r
+            <param name="bufferSize">The length, in bytes, of the message text.</param>\r
+            <remarks>\r
+            <para>\r
+            The following restrictions apply for sending network messages:\r
+            </para>\r
+            <para>\r
+            <list type="table">\r
+                <listheader>\r
+                    <term>Platform</term>\r
+                    <description>Requirements</description>\r
+                </listheader>\r
+                <item>\r
+                    <term>Windows NT</term>\r
+                    <description>\r
+                        <para>\r
+                        No special group membership is required to send a network message.\r
+                        </para>\r
+                        <para>\r
+                        Admin, Accounts, Print, or Server Operator group membership is required to \r
+                        successfully send a network message on a remote server.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>Windows 2000 or later</term>\r
+                    <description>\r
+                        <para>\r
+                        If you send a message on a domain controller that is running Active Directory, \r
+                        access is allowed or denied based on the access control list (ACL) for the securable \r
+                        object. The default ACL permits only Domain Admins and Account Operators to send a network message. \r
+                        </para>\r
+                        <para>\r
+                        On a member server or workstation, only Administrators and Server Operators can send a network message. \r
+                        </para>\r
+                    </description>\r
+                </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            For more information see <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/netmgmt/netmgmt/security_requirements_for_the_network_management_functions.asp">Security Requirements for the Network Management Functions</a>.\r
+            </para>\r
+            </remarks>\r
+            <returns>\r
+            <para>\r
+            If the function succeeds, the return value is zero.\r
+            </para>\r
+            </returns>\r
+        </member>\r
+        <member name="P:log4net.Appender.NetSendAppender.Sender">\r
+            <summary>\r
+            Gets or sets the sender of the message.\r
+            </summary>\r
+            <value>\r
+            The sender of the message.\r
+            </value>\r
+            <remarks>\r
+            If this property is not specified, the message is sent from the local computer.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.NetSendAppender.Recipient">\r
+            <summary>\r
+            Gets or sets the message alias to which the message should be sent.\r
+            </summary>\r
+            <value>\r
+            The recipient of the message.\r
+            </value>\r
+            <remarks>\r
+            This property should always be specified in order to send a message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.NetSendAppender.Server">\r
+            <summary>\r
+            Gets or sets the DNS or NetBIOS name of the remote server on which the function is to execute.\r
+            </summary>\r
+            <value>\r
+            DNS or NetBIOS name of the remote server on which the function is to execute.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            For Windows NT 4.0 and earlier, the string should begin with \\.\r
+            </para>\r
+            <para>\r
+            If this property is not specified, the local computer is used. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.NetSendAppender.SecurityContext">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> used to call the NetSend method.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Unless a <see cref="P:log4net.Appender.NetSendAppender.SecurityContext"/> specified here for this appender\r
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the\r
+            security context to use. The default behavior is to use the security context\r
+            of the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.NetSendAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.OutputDebugStringAppender">\r
+            <summary>\r
+            Appends log events to the OutputDebugString system.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            OutputDebugStringAppender appends log events to the\r
+            OutputDebugString system.\r
+            </para>\r
+            <para>\r
+            The string is passed to the native <c>OutputDebugString</c> \r
+            function.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.OutputDebugStringAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.OutputDebugStringAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.OutputDebugStringAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the logging event to the output debug string API\r
+            </summary>\r
+            <param name="loggingEvent">the event to log</param>\r
+            <remarks>\r
+            <para>\r
+            Write the logging event to the output debug string API\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.OutputDebugStringAppender.OutputDebugString(System.String)">\r
+            <summary>\r
+            Stub for OutputDebugString native method\r
+            </summary>\r
+            <param name="message">the string to output</param>\r
+            <remarks>\r
+            <para>\r
+            Stub for OutputDebugString native method\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.OutputDebugStringAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RemoteSyslogAppender">\r
+            <summary>\r
+            Logs events to a remote syslog daemon.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The BSD syslog protocol is used to remotely log to\r
+            a syslog daemon. The syslogd listens for for messages\r
+            on UDP port 514.\r
+            </para>\r
+            <para>\r
+            The syslog UDP protocol is not authenticated. Most syslog daemons\r
+            do not accept remote log messages because of the security implications.\r
+            You may be able to use the LocalSyslogAppender to talk to a local\r
+            syslog service.\r
+            </para>\r
+            <para>\r
+            There is an RFC 3164 that claims to document the BSD Syslog Protocol.\r
+            This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html.\r
+            This appender generates what the RFC calls an "Original Device Message",\r
+            i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation\r
+            this format of message will be accepted by all current syslog daemon\r
+            implementations. The daemon will attach the current time and the source\r
+            hostname or IP address to any messages received.\r
+            </para>\r
+            <para>\r
+            Syslog messages must have a facility and and a severity. The severity\r
+            is derived from the Level of the logging event.\r
+            The facility must be chosen from the set of defined syslog \r
+            <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The facilities list is predefined\r
+            and cannot be extended.\r
+            </para>\r
+            <para>\r
+            An identifier is specified with each log message. This can be specified\r
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know \r
+            as the tag) must not contain white space. The default value for the\r
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).\r
+            </para>\r
+            </remarks>\r
+            <author>Rob Lyon</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="T:log4net.Appender.UdpAppender">\r
+             <summary>\r
+             Sends logging events as connectionless UDP datagrams to a remote host or a \r
+             multicast group using an <see cref="T:System.Net.Sockets.UdpClient"/>.\r
+             </summary>\r
+             <remarks>\r
+             <para>\r
+             UDP guarantees neither that messages arrive, nor that they arrive in the correct order.\r
+             </para>\r
+             <para>\r
+             To view the logging results, a custom application can be developed that listens for logging \r
+             events.\r
+             </para>\r
+             <para>\r
+             When decoding events send via this appender remember to use the same encoding\r
+             to decode the events as was used to send the events. See the <see cref="P:log4net.Appender.UdpAppender.Encoding"/>\r
+             property to specify the encoding to use.\r
+             </para>\r
+             </remarks>\r
+             <example>\r
+             This example shows how to log receive logging events that are sent \r
+             on IP address 244.0.0.1 and port 8080 to the console. The event is \r
+             encoded in the packet as a unicode string and it is decoded as such. \r
+             <code lang="C#">\r
+             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);\r
+             UdpClient udpClient;\r
+             byte[] buffer;\r
+             string loggingEvent;\r
+             \r
+             try \r
+             {\r
+                 udpClient = new UdpClient(8080);\r
+                 \r
+                 while(true) \r
+                 {\r
+                     buffer = udpClient.Receive(ref remoteEndPoint);\r
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);\r
+                     Console.WriteLine(loggingEvent);\r
+                 }\r
+             } \r
+             catch(Exception e) \r
+             {\r
+                 Console.WriteLine(e.ToString());\r
+             }\r
+             </code>\r
+             <code lang="Visual Basic">\r
+             Dim remoteEndPoint as IPEndPoint\r
+             Dim udpClient as UdpClient\r
+             Dim buffer as Byte()\r
+             Dim loggingEvent as String\r
+             \r
+             Try \r
+                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)\r
+                 udpClient = new UdpClient(8080)\r
+            \r
+                 While True\r
+                     buffer = udpClient.Receive(ByRef remoteEndPoint)\r
+                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)\r
+                     Console.WriteLine(loggingEvent)\r
+                 Wend\r
+             Catch e As Exception\r
+                 Console.WriteLine(e.ToString())\r
+             End Try\r
+             </code>\r
+             <para>\r
+             An example configuration section to log information using this appender to the \r
+             IP 224.0.0.1 on port 8080:\r
+             </para>\r
+             <code lang="XML" escaped="true">\r
+             <appender name="UdpAppender" type="log4net.Appender.UdpAppender">\r
+                 <remoteAddress value="224.0.0.1"/>\r
+                 <remotePort value="8080"/>\r
+                 <layout type="log4net.Layout.PatternLayout" value="%-5level %logger [%ndc] - %message%newline"/>\r
+             </appender>\r
+             </code>\r
+             </example>\r
+             <author>Gert Driesen</author>\r
+             <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.UdpAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.UdpAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            The default constructor initializes all fields to their default values.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.UdpAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            The appender will be ignored if no <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was specified or \r
+            an invalid remote or local TCP port number was specified.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">The required property <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> was not specified.</exception>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">The TCP port number assigned to <see cref="P:log4net.Appender.UdpAppender.LocalPort"/> or <see cref="P:log4net.Appender.UdpAppender.RemotePort"/> is less than <see cref="F:System.Net.IPEndPoint.MinPort"/> or greater than <see cref="F:System.Net.IPEndPoint.MaxPort"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Appender.UdpAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Sends the event using an UDP datagram.\r
+            </para>\r
+            <para>\r
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.UdpAppender.OnClose">\r
+            <summary>\r
+            Closes the UDP connection and releases all resources associated with \r
+            this <see cref="T:log4net.Appender.UdpAppender"/> instance.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Disables the underlying <see cref="T:System.Net.Sockets.UdpClient"/> and releases all managed \r
+            and unmanaged resources associated with the <see cref="T:log4net.Appender.UdpAppender"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.UdpAppender.InitializeClientConnection">\r
+            <summary>\r
+            Initializes the underlying  <see cref="T:System.Net.Sockets.UdpClient"/> connection.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> is initialized and binds to the \r
+            port number from which you intend to communicate.\r
+            </para>\r
+            <para>\r
+            Exceptions are passed to the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.UdpAppender.m_remoteAddress">\r
+            <summary>\r
+            The IP address of the remote host or multicast group to which \r
+            the logging event will be sent.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.UdpAppender.m_remotePort">\r
+            <summary>\r
+            The TCP port number of the remote host or multicast group to \r
+            which the logging event will be sent.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.UdpAppender.m_remoteEndPoint">\r
+            <summary>\r
+            The cached remote endpoint to which the logging events will be sent.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.UdpAppender.m_localPort">\r
+            <summary>\r
+            The TCP port number from which the <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.UdpAppender.m_client">\r
+            <summary>\r
+            The <see cref="T:System.Net.Sockets.UdpClient"/> instance that will be used for sending the \r
+            logging events.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.UdpAppender.m_encoding">\r
+            <summary>\r
+            The encoding to use for the packet.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.RemoteAddress">\r
+            <summary>\r
+            Gets or sets the IP address of the remote host or multicast group to which\r
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.\r
+            </summary>\r
+            <value>\r
+            The IP address of the remote host or multicast group to which the logging event \r
+            will be sent.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Multicast addresses are identified by IP class <b>D</b> addresses (in the range 224.0.0.0 to\r
+            239.255.255.255).  Multicast packets can pass across different networks through routers, so\r
+            it is possible to use multicasts in an Internet scenario as long as your network provider \r
+            supports multicasting.\r
+            </para>\r
+            <para>\r
+            Hosts that want to receive particular multicast messages must register their interest by joining\r
+            the multicast group.  Multicast messages are not sent to networks where no host has joined\r
+            the multicast group.  Class <b>D</b> IP addresses are used for multicast groups, to differentiate\r
+            them from normal host addresses, allowing nodes to easily detect if a message is of interest.\r
+            </para>\r
+            <para>\r
+            Static multicast addresses that are needed globally are assigned by IANA.  A few examples are listed in the table below:\r
+            </para>\r
+            <para>\r
+            <list type="table">\r
+                <listheader>\r
+                    <term>IP Address</term>\r
+                    <description>Description</description>\r
+                </listheader>\r
+                <item>\r
+                    <term>224.0.0.1</term>\r
+                    <description>\r
+                        <para>\r
+                        Sends a message to all system on the subnet.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>224.0.0.2</term>\r
+                    <description>\r
+                        <para>\r
+                        Sends a message to all routers on the subnet.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>224.0.0.12</term>\r
+                    <description>\r
+                        <para>\r
+                        The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            A complete list of actually reserved multicast addresses and their owners in the ranges\r
+            defined by RFC 3171 can be found at the <A href="http://www.iana.org/assignments/multicast-addresses">IANA web site</A>. \r
+            </para>\r
+            <para>\r
+            The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative \r
+            addresses.  These addresses can be reused with other local groups.  Routers are typically \r
+            configured with filters to prevent multicast traffic in this range from flowing outside\r
+            of the local network.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.RemotePort">\r
+            <summary>\r
+            Gets or sets the TCP port number of the remote host or multicast group to which \r
+            the underlying <see cref="T:System.Net.Sockets.UdpClient"/> should sent the logging event.\r
+            </summary>\r
+            <value>\r
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> \r
+            indicating the TCP port number of the remote host or multicast group to which the logging event \r
+            will be sent.\r
+            </value>\r
+            <remarks>\r
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will send messages to this TCP port number\r
+            on the remote host or multicast group.\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">The value specified is less than <see cref="F:System.Net.IPEndPoint.MinPort"/> or greater than <see cref="F:System.Net.IPEndPoint.MaxPort"/>.</exception>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.LocalPort">\r
+            <summary>\r
+            Gets or sets the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.\r
+            </summary>\r
+            <value>\r
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> \r
+            indicating the TCP port number from which the underlying <see cref="T:System.Net.Sockets.UdpClient"/> will communicate.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/> will bind to this port for sending messages.\r
+            </para>\r
+            <para>\r
+            Setting the value to 0 (the default) will cause the udp client not to bind to\r
+            a local port.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">The value specified is less than <see cref="F:System.Net.IPEndPoint.MinPort"/> or greater than <see cref="F:System.Net.IPEndPoint.MaxPort"/>.</exception>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.Encoding">\r
+            <summary>\r
+            Gets or sets <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Appender.UdpAppender.Encoding"/> used to write the packets.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.Client">\r
+            <summary>\r
+            Gets or sets the underlying <see cref="T:System.Net.Sockets.UdpClient"/>.\r
+            </summary>\r
+            <value>\r
+            The underlying <see cref="T:System.Net.Sockets.UdpClient"/>.\r
+            </value>\r
+            <remarks>\r
+            <see cref="T:log4net.Appender.UdpAppender"/> creates a <see cref="T:System.Net.Sockets.UdpClient"/> to send logging events \r
+            over a network.  Classes deriving from <see cref="T:log4net.Appender.UdpAppender"/> can use this\r
+            property to get or set this <see cref="T:System.Net.Sockets.UdpClient"/>.  Use the underlying <see cref="T:System.Net.Sockets.UdpClient"/>\r
+            returned from <see cref="P:log4net.Appender.UdpAppender.Client"/> if you require access beyond that which \r
+            <see cref="T:log4net.Appender.UdpAppender"/> provides.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.RemoteEndPoint">\r
+            <summary>\r
+            Gets or sets the cached remote endpoint to which the logging events should be sent.\r
+            </summary>\r
+            <value>\r
+            The cached remote endpoint to which the logging events will be sent.\r
+            </value>\r
+            <remarks>\r
+            The <see cref="M:log4net.Appender.UdpAppender.ActivateOptions"/> method will initialize the remote endpoint \r
+            with the values of the <see cref="P:log4net.Appender.UdpAppender.RemoteAddress"/> and <see cref="P:log4net.Appender.UdpAppender.RemotePort"/>\r
+            properties.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.UdpAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.DefaultSyslogPort">\r
+            <summary>\r
+            Syslog port 514\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferSize">\r
+            <summary>\r
+            Initial buffer size\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.c_renderBufferMaxCapacity">\r
+            <summary>\r
+            Maximum buffer size before it is recycled\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemoteSyslogAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            This instance of the <see cref="T:log4net.Appender.RemoteSyslogAppender"/> class is set up to write \r
+            to a remote syslog daemon.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemoteSyslogAppender.AddMapping(log4net.Appender.RemoteSyslogAppender.LevelSeverity)">\r
+            <summary>\r
+            Add a mapping of level to severity\r
+            </summary>\r
+            <param name="mapping">The mapping to add</param>\r
+            <remarks>\r
+            <para>\r
+            Add a <see cref="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity"/> mapping to this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemoteSyslogAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This method is called by the <see cref="M:AppenderSkeleton.DoAppend(LoggingEvent)"/> method.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the event to a remote syslog daemon.\r
+            </para>\r
+            <para>\r
+            The format of the output will depend on the appender's layout.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemoteSyslogAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the options for this appender\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initialize the level to syslog severity mappings set on this appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GetSeverity(log4net.Core.Level)">\r
+            <summary>\r
+            Translates a log4net level to a syslog severity.\r
+            </summary>\r
+            <param name="level">A log4net level.</param>\r
+            <returns>A syslog severity.</returns>\r
+            <remarks>\r
+            <para>\r
+            Translates a log4net level to a syslog severity.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemoteSyslogAppender.GeneratePriority(log4net.Appender.RemoteSyslogAppender.SyslogFacility,log4net.Appender.RemoteSyslogAppender.SyslogSeverity)">\r
+            <summary>\r
+            Generate a syslog priority.\r
+            </summary>\r
+            <param name="facility">The syslog facility.</param>\r
+            <param name="severity">The syslog severity.</param>\r
+            <returns>A syslog priority.</returns>\r
+            <remarks>\r
+            <para>\r
+            Generate a syslog priority.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_facility">\r
+            <summary>\r
+            The facility. The default facility is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_identity">\r
+            <summary>\r
+            The message identity\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.m_levelMapping">\r
+            <summary>\r
+            Mapping from level object to syslog severity\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Identity">\r
+            <summary>\r
+            Message identity\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            An identifier is specified with each log message. This can be specified\r
+            by setting the <see cref="P:log4net.Appender.RemoteSyslogAppender.Identity"/> property. The identity (also know \r
+            as the tag) must not contain white space. The default value for the\r
+            identity is the application name (from <see cref="P:log4net.Core.LoggingEvent.Domain"/>).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RemoteSyslogAppender.Facility">\r
+            <summary>\r
+            Syslog facility\r
+            </summary>\r
+            <remarks>\r
+            Set to one of the <see cref="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility"/> values. The list of\r
+            facilities is predefined and cannot be extended. The default value\r
+            is <see cref="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User"/>.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogSeverity">\r
+            <summary>\r
+            syslog severities\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The syslog severities.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Emergency">\r
+            <summary>\r
+            system is unusable\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Alert">\r
+            <summary>\r
+            action must be taken immediately\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Critical">\r
+            <summary>\r
+            critical conditions\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Error">\r
+            <summary>\r
+            error conditions\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Warning">\r
+            <summary>\r
+            warning conditions\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Notice">\r
+            <summary>\r
+            normal but significant condition\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Informational">\r
+            <summary>\r
+            informational\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogSeverity.Debug">\r
+            <summary>\r
+            debug-level messages\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.RemoteSyslogAppender.SyslogFacility">\r
+            <summary>\r
+            syslog facilities\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The syslog facilities\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Kernel">\r
+            <summary>\r
+            kernel messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.User">\r
+            <summary>\r
+            random user-level messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Mail">\r
+            <summary>\r
+            mail system\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Daemons">\r
+            <summary>\r
+            system daemons\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization">\r
+            <summary>\r
+            security/authorization messages\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Syslog">\r
+            <summary>\r
+            messages generated internally by syslogd\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Printer">\r
+            <summary>\r
+            line printer subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.News">\r
+            <summary>\r
+            network news subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Uucp">\r
+            <summary>\r
+            UUCP subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock">\r
+            <summary>\r
+            clock (cron/at) daemon\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Authorization2">\r
+            <summary>\r
+            security/authorization  messages (private)\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ftp">\r
+            <summary>\r
+            ftp daemon\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Ntp">\r
+            <summary>\r
+            NTP subsystem\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Audit">\r
+            <summary>\r
+            log audit\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Alert">\r
+            <summary>\r
+            log alert\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Clock2">\r
+            <summary>\r
+            clock daemon\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local0">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local1">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local2">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local3">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local4">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local5">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local6">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemoteSyslogAppender.SyslogFacility.Local7">\r
+            <summary>\r
+            reserved for local use\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.RemoteSyslogAppender.LevelSeverity">\r
+            <summary>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the syslog severity that is should be logged at.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A class to act as a mapping between the level that a logging call is made at and\r
+            the syslog severity that is should be logged at.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RemoteSyslogAppender.LevelSeverity.Severity">\r
+            <summary>\r
+            The mapped syslog severity for the specified level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Required property.\r
+            The mapped syslog severity for the specified level\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RemotingAppender">\r
+            <summary>\r
+            Delivers logging events to a remote logging sink. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This Appender is designed to deliver events to a remote sink. \r
+            That is any object that implements the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>\r
+            interface. It delivers the events using .NET remoting. The\r
+            object to deliver events to is specified by setting the\r
+            appenders <see cref="P:log4net.Appender.RemotingAppender.Sink"/> property.</para>\r
+            <para>\r
+            The RemotingAppender buffers events before sending them. This allows it to \r
+            make more efficient use of the remoting infrastructure.</para>\r
+            <para>\r
+            Once the buffer is full the events are still not sent immediately. \r
+            They are scheduled to be sent using a pool thread. The effect is that \r
+            the send occurs asynchronously. This is very important for a \r
+            number of non obvious reasons. The remoting infrastructure will \r
+            flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),\r
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the \r
+            remoting boundary. If the server is not contactable then\r
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>\r
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from\r
+            having side effects on the calling application the remoting call must be made\r
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>\r
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then\r
+            the events will block in the thread pool manager until a thread is available.</para>\r
+            <para>\r
+            Because the events are sent asynchronously using pool threads it is possible to close \r
+            this appender before all the queued events have been sent.\r
+            When closing the appender attempts to wait until all the queued events have been sent, but \r
+            this will timeout after 30 seconds regardless.</para>\r
+            <para>\r
+            If this appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>\r
+            event has fired it may not be possible to send all the queued events. During process\r
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>\r
+            event handler is allowed to run for. If the runtime terminates the threads before\r
+            the queued events have been sent then they will be lost. To ensure that all events\r
+            are sent the appender must be closed before the application exits. See \r
+            <see cref="M:log4net.Core.LoggerManager.Shutdown"/> for details on how to shutdown\r
+            log4net programmatically.</para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Daniel Cazzulino</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.RemotingAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.RemotingAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.SendBuffer(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Send the contents of the buffer to the remote sink.\r
+            </summary>\r
+            <remarks>\r
+            The events are not sent immediately. They are scheduled to be sent\r
+            using a pool thread. The effect is that the send occurs asynchronously.\r
+            This is very important for a number of non obvious reasons. The remoting\r
+            infrastructure will flow thread local variables (stored in the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>),\r
+            if they are marked as <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>, across the \r
+            remoting boundary. If the server is not contactable then\r
+            the remoting infrastructure will clear the <see cref="T:System.Runtime.Remoting.Messaging.ILogicalThreadAffinative"/>\r
+            objects from the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/>. To prevent a logging failure from\r
+            having side effects on the calling application the remoting call must be made\r
+            from a separate thread to the one used by the application. A <see cref="T:System.Threading.ThreadPool"/>\r
+            thread is used for this. If no <see cref="T:System.Threading.ThreadPool"/> thread is available then\r
+            the events will block in the thread pool manager until a thread is available.\r
+            </remarks>\r
+            <param name="events">The events to send.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.OnClose">\r
+            <summary>\r
+            Override base class close.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method waits while there are queued work items. The events are\r
+            sent asynchronously using <see cref="T:System.Threading.ThreadPool"/> work items. These items\r
+            will be sent once a thread pool thread is available to send them, therefore\r
+            it is possible to close the appender before all the queued events have been\r
+            sent.</para>\r
+            <para>\r
+            This method attempts to wait until all the queued events have been sent, but this \r
+            method will timeout after 30 seconds regardless.</para>\r
+            <para>\r
+            If the appender is being closed because the <see cref="E:System.AppDomain.ProcessExit"/>\r
+            event has fired it may not be possible to send all the queued events. During process\r
+            exit the runtime limits the time that a <see cref="E:System.AppDomain.ProcessExit"/>\r
+            event handler is allowed to run for.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.BeginAsyncSend">\r
+            <summary>\r
+            A work item is being queued into the thread pool\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.EndAsyncSend">\r
+            <summary>\r
+            A work item from the thread pool has completed\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.SendBufferCallback(System.Object)">\r
+            <summary>\r
+            Send the contents of the buffer to the remote sink.\r
+            </summary>\r
+            <remarks>\r
+            This method is designed to be used with the <see cref="T:System.Threading.ThreadPool"/>.\r
+            This method expects to be passed an array of <see cref="T:log4net.Core.LoggingEvent"/>\r
+            objects in the state param.\r
+            </remarks>\r
+            <param name="state">the logging events to send</param>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkUrl">\r
+            <summary>\r
+            The URL of the remote sink.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemotingAppender.m_sinkObj">\r
+            <summary>\r
+            The local proxy (.NET remoting) for the remote logging sink.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemotingAppender.m_queuedCallbackCount">\r
+            <summary>\r
+            The number of queued callbacks currently waiting or executing\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RemotingAppender.m_workQueueEmptyEvent">\r
+            <summary>\r
+            Event used to signal when there are no queued work items\r
+            </summary>\r
+            <remarks>\r
+            This event is set when there are no queued work items. In this\r
+            state it is safe to close the appender.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RemotingAppender.Sink">\r
+            <summary>\r
+            Gets or sets the URL of the well-known object that will accept \r
+            the logging events.\r
+            </summary>\r
+            <value>\r
+            The well-known URL of the remote sink.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The URL of the remoting sink that will accept logging events.\r
+            The sink must implement the <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/>\r
+            interface.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink">\r
+            <summary>\r
+            Interface used to deliver <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.\r
+            </summary>\r
+            <remarks>\r
+            This interface must be implemented by a remoting sink\r
+            if the <see cref="T:log4net.Appender.RemotingAppender"/> is to be used\r
+            to deliver logging events to the sink.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RemotingAppender.IRemoteLoggingSink.LogEvents(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Delivers logging events to the remote sink\r
+            </summary>\r
+            <param name="events">Array of events to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Delivers logging events to the remote sink\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RollingFileAppender">\r
+            <summary>\r
+            Appender that rolls log files based on size or date or both.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            RollingFileAppender can roll log files based on size or date or both\r
+            depending on the setting of the <see cref="P:log4net.Appender.RollingFileAppender.RollingStyle"/> property.\r
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Size"/> the log file will be rolled\r
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.\r
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Date"/> the log file will be rolled\r
+            once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property\r
+            is crossed.\r
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/> the log file will be\r
+            rolled once the date boundary specified in the <see cref="P:log4net.Appender.RollingFileAppender.DatePattern"/> property\r
+            is crossed, but within a date boundary the file will also be rolled\r
+            once its size exceeds the <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/>.\r
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> the log file will be rolled when\r
+            the appender is configured. This effectively means that the log file can be\r
+            rolled once per program execution.\r
+            </para>\r
+            <para>\r
+            A of few additional optional features have been added:\r
+            <list type="bullet">\r
+            <item>Attach date pattern for current log file <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/></item>\r
+            <item>Backup number increments for newer files <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/></item>\r
+            <item>Infinite number of backups by file size <see cref="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups"/></item>\r
+            </list>\r
+            </para>\r
+            \r
+            <note>\r
+            <para>\r
+            For large or infinite numbers of backup files a <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> \r
+            greater than zero is highly recommended, otherwise all the backup files need\r
+            to be renamed each time a new backup is created.\r
+            </para>\r
+            <para>\r
+            When Date/Time based rolling is used setting <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> \r
+            to <see langword="true"/> will reduce the number of file renamings to few or none.\r
+            </para>\r
+            </note>\r
+            \r
+            <note type="caution">\r
+            <para>\r
+            Changing <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> or <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> without clearing\r
+            the log file directory of backup files will cause unexpected and unwanted side effects.  \r
+            </para>\r
+            </note>\r
+            \r
+            <para>\r
+            If Date/Time based rolling is enabled this appender will attempt to roll existing files\r
+            in the directory without a Date/Time tag based on the last write date of the base log file.\r
+            The appender only rolls the log file when a message is logged. If Date/Time based rolling \r
+            is enabled then the appender will not roll the log file at the Date/Time boundary but\r
+            at the point when the next message is logged after the boundary has been crossed.\r
+            </para>\r
+            \r
+            <para>\r
+            The <see cref="T:log4net.Appender.RollingFileAppender"/> extends the <see cref="T:log4net.Appender.FileAppender"/> and\r
+            has the same behavior when opening the log file.\r
+            The appender will first try to open the file for writing when <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>\r
+            is called. This will typically be during configuration.\r
+            If the file cannot be opened for writing the appender will attempt\r
+            to open the file again each time a message is logged to the appender.\r
+            If the file cannot be opened for writing when a message is logged then\r
+            the message will be discarded by this appender.\r
+            </para>\r
+            <para>\r
+            When rolling a backup file necessitates deleting an older backup file the\r
+            file to be deleted is moved to a temporary name before being deleted.\r
+            </para>\r
+            \r
+            <note type="caution">\r
+            <para>\r
+            A maximum number of backup files when rolling on date/time boundaries is not supported.\r
+            </para>\r
+            </note>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Aspi Havewala</author>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Edward Smit</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.RollingFileAppender"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.declaringType">\r
+            <summary>\r
+            The fully qualified type of the RollingFileAppender class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.SetQWForFiles(System.IO.TextWriter)">\r
+            <summary>\r
+            Sets the quiet writer being used.\r
+            </summary>\r
+            <remarks>\r
+            This method can be overridden by sub classes.\r
+            </remarks>\r
+            <param name="writer">the writer to set</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write out a logging event.\r
+            </summary>\r
+            <param name="loggingEvent">the event to write to file.</param>\r
+            <remarks>\r
+            <para>\r
+            Handles append time behavior for RollingFileAppender.  This checks\r
+            if a roll over either by date (checked first) or time (checked second)\r
+            is need and then appends to the file last.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.Append(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Write out an array of logging events.\r
+            </summary>\r
+            <param name="loggingEvents">the events to write to file.</param>\r
+            <remarks>\r
+            <para>\r
+            Handles append time behavior for RollingFileAppender.  This checks\r
+            if a roll over either by date (checked first) or time (checked second)\r
+            is need and then appends to the file last.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.AdjustFileBeforeAppend">\r
+            <summary>\r
+            Performs any required rolling before outputting the next event\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Handles append time behavior for RollingFileAppender.  This checks\r
+            if a roll over either by date (checked first) or time (checked second)\r
+            is need and then appends to the file last.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.OpenFile(System.String,System.Boolean)">\r
+            <summary>\r
+            Creates and opens the file for logging.  If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/>\r
+            is false then the fully qualified name is determined and used.\r
+            </summary>\r
+            <param name="fileName">the name of the file to open</param>\r
+            <param name="append">true to append to existing file</param>\r
+            <remarks>\r
+            <para>This method will ensure that the directory structure\r
+            for the <paramref name="fileName"/> specified exists.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.GetNextOutputFileName(System.String)">\r
+            <summary>\r
+            Get the current output file name\r
+            </summary>\r
+            <param name="fileName">the base file name</param>\r
+            <returns>the output file name</returns>\r
+            <remarks>\r
+            The output file name is based on the base fileName specified.\r
+            If <see cref="P:log4net.Appender.RollingFileAppender.StaticLogFileName"/> is set then the output \r
+            file name is the same as the base file passed in. Otherwise\r
+            the output file depends on the date pattern, on the count\r
+            direction or both.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.DetermineCurSizeRollBackups">\r
+            <summary>\r
+            Determines curSizeRollBackups (only within the current roll point)\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.GetWildcardPatternForFile(System.String)">\r
+            <summary>\r
+            Generates a wildcard pattern that can be used to find all files\r
+            that are similar to the base file name.\r
+            </summary>\r
+            <param name="baseFileName"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.GetExistingFiles(System.String)">\r
+            <summary>\r
+            Builds a list of filenames for all files matching the base filename plus a file\r
+            pattern.\r
+            </summary>\r
+            <param name="baseFilePath"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverIfDateBoundaryCrossing">\r
+            <summary>\r
+            Initiates a roll over if needed for crossing a date boundary since the last run.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.ExistingInit">\r
+            <summary>\r
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes based on existing conditions at time of <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/>.\r
+            The following is done\r
+            <list type="bullet">\r
+            <item>determine curSizeRollBackups (only within the current roll point)</item>\r
+            <item>initiates a roll over if needed for crossing a date boundary since the last run.</item>\r
+            </list>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeFromOneFile(System.String,System.String)">\r
+            <summary>\r
+            Does the work of bumping the 'current' file counter higher\r
+            to the highest count when an incremental file name is seen.\r
+            The highest count is either the first file (when count direction\r
+            is greater than 0) or the last file (when count direction less than 0).\r
+            In either case, we want to know the highest count that is present.\r
+            </summary>\r
+            <param name="baseFile"></param>\r
+            <param name="curFileName"></param>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.GetBackUpIndex(System.String)">\r
+            <summary>\r
+            Attempts to extract a number from the end of the file name that indicates\r
+            the number of the times the file has been rolled over.\r
+            </summary>\r
+            <remarks>\r
+            Certain date pattern extensions like yyyyMMdd will be parsed as valid backup indexes.\r
+            </remarks>\r
+            <param name="curFileName"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.InitializeRollBackups(System.String,System.Collections.ArrayList)">\r
+            <summary>\r
+            Takes a list of files and a base file name, and looks for \r
+            'incremented' versions of the base file.  Bumps the max\r
+            count up to the highest count seen.\r
+            </summary>\r
+            <param name="baseFile"></param>\r
+            <param name="arrayFiles"></param>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.ComputeCheckPeriod(System.String)">\r
+            <summary>\r
+            Calculates the RollPoint for the datePattern supplied.\r
+            </summary>\r
+            <param name="datePattern">the date pattern to calculate the check period for</param>\r
+            <returns>The RollPoint that is most accurate for the date pattern supplied</returns>\r
+            <remarks>\r
+            Essentially the date pattern is examined to determine what the\r
+            most suitable roll point is. The roll point chosen is the roll point\r
+            with the smallest period that can be detected using the date pattern\r
+            supplied. i.e. if the date pattern only outputs the year, month, day \r
+            and hour then the smallest roll point that can be detected would be\r
+            and hourly roll point as minutes could not be detected.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.RollingFileAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            Sets initial conditions including date/time roll over information, first check,\r
+            scheduledFilename, and calls <see cref="M:log4net.Appender.RollingFileAppender.ExistingInit"/> to initialize\r
+            the current number of backups.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.CombinePath(System.String,System.String)">\r
+            <summary>\r
+            \r
+            </summary>\r
+            <param name="path1"></param>\r
+            <param name="path2">.1, .2, .3, etc.</param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverTime(System.Boolean)">\r
+            <summary>\r
+            Rollover the file(s) to date/time tagged file(s).\r
+            </summary>\r
+            <param name="fileIsOpen">set to true if the file to be rolled is currently open</param>\r
+            <remarks>\r
+            <para>\r
+            Rollover the file(s) to date/time tagged file(s).\r
+            Resets curSizeRollBackups. \r
+            If fileIsOpen is set then the new file is opened (through SafeOpenFile).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.RollFile(System.String,System.String)">\r
+            <summary>\r
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>.\r
+            </summary>\r
+            <param name="fromFile">Name of existing file to roll.</param>\r
+            <param name="toFile">New name for file.</param>\r
+            <remarks>\r
+            <para>\r
+            Renames file <paramref name="fromFile"/> to file <paramref name="toFile"/>. It\r
+            also checks for existence of target file and deletes if it does.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.FileExists(System.String)">\r
+            <summary>\r
+            Test if a file exists at a specified path\r
+            </summary>\r
+            <param name="path">the path to the file</param>\r
+            <returns>true if the file exists</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if a file exists at a specified path\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.DeleteFile(System.String)">\r
+            <summary>\r
+            Deletes the specified file if it exists.\r
+            </summary>\r
+            <param name="fileName">The file to delete.</param>\r
+            <remarks>\r
+            <para>\r
+            Delete a file if is exists.\r
+            The file is first moved to a new filename then deleted.\r
+            This allows the file to be removed even when it cannot\r
+            be deleted, but it still can be moved.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverSize">\r
+            <summary>\r
+            Implements file roll base on file size.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If the maximum number of size based backups is reached\r
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest\r
+            file is deleted -- its index determined by the sign of countDirection.\r
+            If <c>countDirection</c> &lt; 0, then files\r
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}\r
+            are renamed to {<c>File.2</c>, ...,\r
+            <c>File.curSizeRollBackups</c>}. Moreover, <c>File</c> is\r
+            renamed <c>File.1</c> and closed.\r
+            </para>\r
+            <para>\r
+            A new file is created to receive further log output.\r
+            </para>\r
+            <para>\r
+            If <c>maxSizeRollBackups</c> is equal to zero, then the\r
+            <c>File</c> is truncated with no backup files created.\r
+            </para>\r
+            <para>\r
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is\r
+            renamed if needed and no files are deleted.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.RollOverRenameFiles(System.String)">\r
+            <summary>\r
+            Implements file roll.\r
+            </summary>\r
+            <param name="baseFileName">the base name to rename</param>\r
+            <remarks>\r
+            <para>\r
+            If the maximum number of size based backups is reached\r
+            (<c>curSizeRollBackups == maxSizeRollBackups</c>) then the oldest\r
+            file is deleted -- its index determined by the sign of countDirection.\r
+            If <c>countDirection</c> &lt; 0, then files\r
+            {<c>File.1</c>, ..., <c>File.curSizeRollBackups -1</c>}\r
+            are renamed to {<c>File.2</c>, ...,\r
+            <c>File.curSizeRollBackups</c>}. \r
+            </para>\r
+            <para>\r
+            If <c>maxSizeRollBackups</c> is equal to zero, then the\r
+            <c>File</c> is truncated with no backup files created.\r
+            </para>\r
+            <para>\r
+            If <c>maxSizeRollBackups</c> &lt; 0, then <c>File</c> is\r
+            renamed if needed and no files are deleted.\r
+            </para>\r
+            <para>\r
+            This is called by <see cref="M:log4net.Appender.RollingFileAppender.RollOverSize"/> to rename the files.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.RollingFileAppender.NextCheckDate(System.DateTime,log4net.Appender.RollingFileAppender.RollPoint)">\r
+            <summary>\r
+            Get the start time of the next window for the current rollpoint\r
+            </summary>\r
+            <param name="currentDateTime">the current date</param>\r
+            <param name="rollPoint">the type of roll point we are working with</param>\r
+            <returns>the start time for the next roll point an interval after the currentDateTime date</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the date of the next roll point after the currentDateTime date passed to the method.\r
+            </para>\r
+            <para>\r
+            The basic strategy is to subtract the time parts that are less significant\r
+            than the rollpoint from the current time. This should roll the time back to\r
+            the start of the time window for the current rollpoint. Then we add 1 window\r
+            worth of time and get the start time of the next window for the rollpoint.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_dateTime">\r
+            <summary>\r
+            This object supplies the current date/time.  Allows test code to plug in\r
+            a method to control this class when testing date/time based rolling. The default\r
+            implementation uses the underlying value of DateTime.Now.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_datePattern">\r
+            <summary>\r
+            The date pattern. By default, the pattern is set to <c>".yyyy-MM-dd"</c> \r
+            meaning daily rollover.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_scheduledFilename">\r
+            <summary>\r
+            The actual formatted filename that is currently being written to\r
+            or will be the file transferred to on roll over\r
+            (based on staticLogFileName).\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_nextCheck">\r
+            <summary>\r
+            The timestamp when we shall next recompute the filename.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_now">\r
+            <summary>\r
+            Holds date of last roll over\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollPoint">\r
+            <summary>\r
+            The type of rolling done\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxFileSize">\r
+            <summary>\r
+            The default maximum file size is 10MB\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_maxSizeRollBackups">\r
+            <summary>\r
+            There is zero backup files by default\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_curSizeRollBackups">\r
+            <summary>\r
+            How many sized based backups have been made so far\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_countDirection">\r
+            <summary>\r
+            The rolling file count direction. \r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollingStyle">\r
+            <summary>\r
+            The rolling mode used in this appender.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollDate">\r
+            <summary>\r
+            Cache flag set if we are rolling by date.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_rollSize">\r
+            <summary>\r
+            Cache flag set if we are rolling by size.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_staticLogFileName">\r
+            <summary>\r
+            Value indicating whether to always log to the same file.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_preserveLogFileNameExtension">\r
+            <summary>\r
+            Value indicating whether to preserve the file name extension when rolling.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.m_baseFileName">\r
+            <summary>\r
+            FileName provided in configuration.  Used for rolling properly\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.s_date1970">\r
+            <summary>\r
+            The 1st of January 1970 in UTC\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.DateTimeStrategy">\r
+            <summary>\r
+            Gets or sets the strategy for determining the current date and time. The default\r
+            implementation is to use LocalDateTime which internally calls through to DateTime.Now. \r
+            DateTime.UtcNow may be used on frameworks newer than .NET 1.0 by specifying\r
+            <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.\r
+            </summary>\r
+            <value>\r
+            An implementation of the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> interface which returns the current date and time.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> used to return the current date and time.\r
+            </para>\r
+            <para>\r
+            There are two built strategies for determining the current date and time, \r
+            <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>\r
+            and <see cref="T:log4net.Appender.RollingFileAppender.UniversalDateTime"/>.\r
+            </para>\r
+            <para>\r
+            The default strategy is <see cref="T:log4net.Appender.RollingFileAppender.LocalDateTime"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.DatePattern">\r
+            <summary>\r
+            Gets or sets the date pattern to be used for generating file names\r
+            when rolling over on date.\r
+            </summary>\r
+            <value>\r
+            The date pattern to be used for generating file names when rolling \r
+            over on date.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Takes a string in the same format as expected by \r
+            <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/>.\r
+            </para>\r
+            <para>\r
+            This property determines the rollover schedule when rolling over\r
+            on date.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.MaxSizeRollBackups">\r
+            <summary>\r
+            Gets or sets the maximum number of backup files that are kept before\r
+            the oldest is erased.\r
+            </summary>\r
+            <value>\r
+            The maximum number of backup files that are kept before the oldest is\r
+            erased.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If set to zero, then there will be no backup files and the log file \r
+            will be truncated when it reaches <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/>.  \r
+            </para>\r
+            <para>\r
+            If a negative number is supplied then no deletions will be made.  Note \r
+            that this could result in very slow performance as a large number of \r
+            files are rolled over unless <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> is used.\r
+            </para>\r
+            <para>\r
+            The maximum applies to <b>each</b> time based group of files and \r
+            <b>not</b> the total.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.MaxFileSize">\r
+            <summary>\r
+            Gets or sets the maximum size that the output file is allowed to reach\r
+            before being rolled over to backup files.\r
+            </summary>\r
+            <value>\r
+            The maximum size in bytes that the output file is allowed to reach before being \r
+            rolled over to backup files.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This property is equivalent to <see cref="P:log4net.Appender.RollingFileAppender.MaximumFileSize"/> except\r
+            that it is required for differentiating the setter taking a\r
+            <see cref="T:System.Int64"/> argument from the setter taking a <see cref="T:System.String"/> \r
+            argument.\r
+            </para>\r
+            <para>\r
+            The default maximum file size is 10MB (10*1024*1024).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.MaximumFileSize">\r
+            <summary>\r
+            Gets or sets the maximum size that the output file is allowed to reach\r
+            before being rolled over to backup files.\r
+            </summary>\r
+            <value>\r
+            The maximum size that the output file is allowed to reach before being \r
+            rolled over to backup files.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This property allows you to specify the maximum size with the\r
+            suffixes "KB", "MB" or "GB" so that the size is interpreted being \r
+            expressed respectively in kilobytes, megabytes or gigabytes. \r
+            </para>\r
+            <para>\r
+            For example, the value "10KB" will be interpreted as 10240 bytes.\r
+            </para>\r
+            <para>\r
+            The default maximum file size is 10MB.\r
+            </para>\r
+            <para>\r
+            If you have the option to set the maximum file size programmatically\r
+            consider using the <see cref="P:log4net.Appender.RollingFileAppender.MaxFileSize"/> property instead as this\r
+            allows you to set the size in bytes as a <see cref="T:System.Int64"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.CountDirection">\r
+            <summary>\r
+            Gets or sets the rolling file count direction. \r
+            </summary>\r
+            <value>\r
+            The rolling file count direction.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Indicates if the current file is the lowest numbered file or the\r
+            highest numbered file.\r
+            </para>\r
+            <para>\r
+            By default newer files have lower numbers (<see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &lt; 0),\r
+            i.e. log.1 is most recent, log.5 is the 5th backup, etc...\r
+            </para>\r
+            <para>\r
+            <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 does the opposite i.e.\r
+            log.1 is the first backup made, log.5 is the 5th backup made, etc.\r
+            For infinite backups use <see cref="P:log4net.Appender.RollingFileAppender.CountDirection"/> &gt;= 0 to reduce \r
+            rollover costs.\r
+            </para>\r
+            <para>The default file count direction is -1.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.RollingStyle">\r
+            <summary>\r
+            Gets or sets the rolling style.\r
+            </summary>\r
+            <value>The rolling style.</value>\r
+            <remarks>\r
+            <para>\r
+            The default rolling style is <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Composite"/>.\r
+            </para>\r
+            <para>\r
+            When set to <see cref="F:log4net.Appender.RollingFileAppender.RollingMode.Once"/> this appender's\r
+            <see cref="P:log4net.Appender.FileAppender.AppendToFile"/> property is set to <c>false</c>, otherwise\r
+            the appender would append to a single file rather than rolling\r
+            the file each time it is opened.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.PreserveLogFileNameExtension">\r
+            <summary>\r
+            Gets or sets a value indicating whether to preserve the file name extension when rolling.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if the file name extension should be preserved.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            By default file.log is rolled to file.log.yyyy-MM-dd or file.log.curSizeRollBackup.\r
+            However, under Windows the new file name will loose any program associations as the\r
+            extension is changed. Optionally file.log can be renamed to file.yyyy-MM-dd.log or\r
+            file.curSizeRollBackup.log to maintain any program associations.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.StaticLogFileName">\r
+            <summary>\r
+            Gets or sets a value indicating whether to always log to\r
+            the same file.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if always should be logged to the same file, otherwise <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            By default file.log is always the current file.  Optionally\r
+            file.log.yyyy-mm-dd for current formatted datePattern can by the currently\r
+            logging file (or file.log.curSizeRollBackup or even\r
+            file.log.yyyy-mm-dd.curSizeRollBackup).\r
+            </para>\r
+            <para>\r
+            This will make time based rollovers with a large number of backups \r
+            much faster as the appender it won't have to rename all the backups!\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RollingFileAppender.RollingMode">\r
+            <summary>\r
+            Style of rolling to use\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Style of rolling to use\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Once">\r
+            <summary>\r
+            Roll files once per program execution\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Roll files once per program execution.\r
+            Well really once each time this appender is\r
+            configured.\r
+            </para>\r
+            <para>\r
+            Setting this option also sets <c>AppendToFile</c> to\r
+            <c>false</c> on the <c>RollingFileAppender</c>, otherwise\r
+            this appender would just be a normal file appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Size">\r
+            <summary>\r
+            Roll files based only on the size of the file\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Date">\r
+            <summary>\r
+            Roll files based only on the date\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollingMode.Composite">\r
+            <summary>\r
+            Roll files based on both the size and date of the file\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.RollingFileAppender.RollPoint">\r
+            <summary>\r
+            The code assumes that the following 'time' constants are in a increasing sequence.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The code assumes that the following 'time' constants are in a increasing sequence.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.InvalidRollPoint">\r
+            <summary>\r
+            Roll the log not based on the date\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMinute">\r
+            <summary>\r
+            Roll the log for each minute\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfHour">\r
+            <summary>\r
+            Roll the log for each hour\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.HalfDay">\r
+            <summary>\r
+            Roll the log twice a day (midday and midnight)\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfDay">\r
+            <summary>\r
+            Roll the log each day (midnight)\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfWeek">\r
+            <summary>\r
+            Roll the log each week\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.RollingFileAppender.RollPoint.TopOfMonth">\r
+            <summary>\r
+            Roll the log each month\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Appender.RollingFileAppender.IDateTime">\r
+            <summary>\r
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.\r
+            </summary>\r
+            <remarks>\r
+            This interface is used to supply Date/Time information to the <see cref="T:log4net.Appender.RollingFileAppender"/>.\r
+            Used primarily to allow test classes to plug themselves in so they can\r
+            supply test date/times.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.IDateTime.Now">\r
+            <summary>\r
+            Gets the <i>current</i> time.\r
+            </summary>\r
+            <value>The <i>current</i> time.</value>\r
+            <remarks>\r
+            <para>\r
+            Gets the <i>current</i> time.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RollingFileAppender.LocalDateTime">\r
+            <summary>\r
+            Default implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.LocalDateTime.Now">\r
+            <summary>\r
+            Gets the <b>current</b> time.\r
+            </summary>\r
+            <value>The <b>current</b> time.</value>\r
+            <remarks>\r
+            <para>\r
+            Gets the <b>current</b> time.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.RollingFileAppender.UniversalDateTime">\r
+            <summary>\r
+            Implementation of <see cref="T:log4net.Appender.RollingFileAppender.IDateTime"/> that returns the current time as the coordinated universal time (UTC).\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.RollingFileAppender.UniversalDateTime.Now">\r
+            <summary>\r
+            Gets the <b>current</b> time.\r
+            </summary>\r
+            <value>The <b>current</b> time.</value>\r
+            <remarks>\r
+            <para>\r
+            Gets the <b>current</b> time.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.SmtpAppender">\r
+            <summary>\r
+            Send an e-mail when a specific logging event occurs, typically on errors \r
+            or fatal errors.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The number of logging events delivered in this e-mail depend on\r
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The\r
+            <see cref="T:log4net.Appender.SmtpAppender"/> keeps only the last\r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its \r
+            cyclic buffer. This keeps memory requirements at a reasonable level while \r
+            still delivering useful application context.\r
+            </para>\r
+            <note type="caution">\r
+            Authentication and setting the server Port are only available on the MS .NET 1.1 runtime.\r
+            For these features to be enabled you need to ensure that you are using a version of\r
+            the log4net assembly that is built against the MS .NET 1.1 framework and that you are\r
+            running the your application on the MS .NET 1.1 runtime. On all other platforms only sending\r
+            unauthenticated messages to a server listening on port 25 (the default) is supported.\r
+            </note>\r
+            <para>\r
+            Authentication is supported by setting the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property to\r
+            either <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> or <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>.\r
+            If using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> authentication then the <see cref="P:log4net.Appender.SmtpAppender.Username"/>\r
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> properties must also be set.\r
+            </para>\r
+            <para>\r
+            To set the SMTP server port use the <see cref="P:log4net.Appender.SmtpAppender.Port"/> property. The default port is 25.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpAppender.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpAppender.SendBuffer(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Sends the contents of the cyclic buffer as an e-mail message.\r
+            </summary>\r
+            <param name="events">The logging events to send.</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpAppender.SendEmail(System.String)">\r
+            <summary>\r
+            Send the email message\r
+            </summary>\r
+            <param name="messageBody">the body text to include in the mail</param>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.To">\r
+            <summary>\r
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses (use semicolon on .NET 1.1 and comma for later versions).\r
+            </summary>\r
+            <value>\r
+            <para>\r
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.\r
+            </para>\r
+            <para>\r
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.\r
+            </para>\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.\r
+            </para>\r
+            <para>\r
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Cc">\r
+            <summary>\r
+            Gets or sets a comma- or semicolon-delimited list of recipient e-mail addresses \r
+            that will be carbon copied (use semicolon on .NET 1.1 and comma for later versions).\r
+            </summary>\r
+            <value>\r
+            <para>\r
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.\r
+            </para>\r
+            <para>\r
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.\r
+            </para>\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            For .NET 1.1 (System.Web.Mail): A semicolon-delimited list of e-mail addresses.\r
+            </para>\r
+            <para>\r
+            For .NET 2.0 (System.Net.Mail): A comma-delimited list of e-mail addresses.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Bcc">\r
+            <summary>\r
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses\r
+            that will be blind carbon copied.\r
+            </summary>\r
+            <value>\r
+            A semicolon-delimited list of e-mail addresses.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            A semicolon-delimited list of recipient e-mail addresses.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.From">\r
+            <summary>\r
+            Gets or sets the e-mail address of the sender.\r
+            </summary>\r
+            <value>\r
+            The e-mail address of the sender.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The e-mail address of the sender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Subject">\r
+            <summary>\r
+            Gets or sets the subject line of the e-mail message.\r
+            </summary>\r
+            <value>\r
+            The subject line of the e-mail message.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The subject line of the e-mail message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.SmtpHost">\r
+            <summary>\r
+            Gets or sets the name of the SMTP relay mail server to use to send \r
+            the e-mail messages.\r
+            </summary>\r
+            <value>\r
+            The name of the e-mail relay server. If SmtpServer is not set, the \r
+            name of the local SMTP server is used.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of the e-mail relay server. If SmtpServer is not set, the \r
+            name of the local SMTP server is used.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.LocationInfo">\r
+            <summary>\r
+            Obsolete\r
+            </summary>\r
+            <remarks>\r
+            Use the BufferingAppenderSkeleton Fix methods instead \r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            Obsolete property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Authentication">\r
+            <summary>\r
+            The mode to use to authentication with the SMTP server\r
+            </summary>\r
+            <remarks>\r
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>\r
+            <para>\r
+            Valid Authentication mode values are: <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>, \r
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, and <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/>. \r
+            The default value is <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None"/>. When using \r
+            <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/> you must specify the <see cref="P:log4net.Appender.SmtpAppender.Username"/> \r
+            and <see cref="P:log4net.Appender.SmtpAppender.Password"/> to use to authenticate.\r
+            When using <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm"/> the Windows credentials for the current\r
+            thread, if impersonating, or the process will be used to authenticate. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Username">\r
+            <summary>\r
+            The username to use to authenticate with the SMTP server\r
+            </summary>\r
+            <remarks>\r
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>\r
+            <para>\r
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when \r
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, \r
+            otherwise the username will be ignored. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Password">\r
+            <summary>\r
+            The password to use to authenticate with the SMTP server\r
+            </summary>\r
+            <remarks>\r
+            <note type="caution">Authentication is only available on the MS .NET 1.1 runtime.</note>\r
+            <para>\r
+            A <see cref="P:log4net.Appender.SmtpAppender.Username"/> and <see cref="P:log4net.Appender.SmtpAppender.Password"/> must be specified when \r
+            <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> is set to <see cref="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic"/>, \r
+            otherwise the password will be ignored. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Port">\r
+            <summary>\r
+            The port on which the SMTP server is listening\r
+            </summary>\r
+            <remarks>\r
+            <note type="caution">Server Port is only available on the MS .NET 1.1 runtime.</note>\r
+            <para>\r
+            The port on which the SMTP server is listening. The default\r
+            port is <c>25</c>. The Port can only be changed when running on\r
+            the MS .NET 1.1 runtime.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.Priority">\r
+            <summary>\r
+            Gets or sets the priority of the e-mail message\r
+            </summary>\r
+            <value>\r
+            One of the <see cref="T:System.Net.Mail.MailPriority"/> values.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Sets the priority of the e-mails generated by this\r
+            appender. The default priority is <see cref="F:System.Net.Mail.MailPriority.Normal"/>.\r
+            </para>\r
+            <para>\r
+            If you are using this appender to report errors then\r
+            you may want to set the priority to <see cref="F:System.Net.Mail.MailPriority.High"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.EnableSsl">\r
+            <summary>\r
+            Enable or disable use of SSL when sending e-mail message\r
+            </summary>\r
+            <remarks>\r
+            This is available on MS .NET 2.0 runtime and higher\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.ReplyTo">\r
+            <summary>\r
+            Gets or sets the reply-to e-mail address.\r
+            </summary>\r
+            <remarks>\r
+            This is available on MS .NET 2.0 runtime and higher\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.SubjectEncoding">\r
+            <summary>\r
+            Gets or sets the subject encoding to be used.\r
+            </summary>\r
+            <remarks>\r
+            The default encoding is the operating system's current ANSI codepage.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.BodyEncoding">\r
+            <summary>\r
+            Gets or sets the body encoding to be used.\r
+            </summary>\r
+            <remarks>\r
+            The default encoding is the operating system's current ANSI codepage.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.SmtpAppender.SmtpAuthentication">\r
+            <summary>\r
+            Values for the <see cref="P:log4net.Appender.SmtpAppender.Authentication"/> property.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            SMTP authentication modes.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.None">\r
+            <summary>\r
+            No authentication\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Basic">\r
+            <summary>\r
+            Basic authentication.\r
+            </summary>\r
+            <remarks>\r
+            Requires a username and password to be supplied\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.SmtpAppender.SmtpAuthentication.Ntlm">\r
+            <summary>\r
+            Integrated authentication\r
+            </summary>\r
+            <remarks>\r
+            Uses the Windows credentials from the current thread or process to authenticate.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.SmtpPickupDirAppender">\r
+            <summary>\r
+            Send an email when a specific logging event occurs, typically on errors \r
+            or fatal errors. Rather than sending via smtp it writes a file into the\r
+            directory specified by <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>. This allows services such\r
+            as the IIS SMTP agent to manage sending the messages.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The configuration for this appender is identical to that of the <c>SMTPAppender</c>,\r
+            except that instead of specifying the <c>SMTPAppender.SMTPHost</c> you specify\r
+            <see cref="P:log4net.Appender.SmtpPickupDirAppender.PickupDir"/>.\r
+            </para>\r
+            <para>\r
+            The number of logging events delivered in this e-mail depend on\r
+            the value of <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option. The\r
+            <see cref="T:log4net.Appender.SmtpPickupDirAppender"/> keeps only the last\r
+            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> logging events in its \r
+            cyclic buffer. This keeps memory requirements at a reasonable level while \r
+            still delivering useful application context.\r
+            </para>\r
+            </remarks>\r
+            <author>Niall Daley</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.SendBuffer(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Sends the contents of the cyclic buffer as an e-mail message.\r
+            </summary>\r
+            <param name="events">The logging events to send.</param>\r
+            <remarks>\r
+            <para>\r
+            Sends the contents of the cyclic buffer as an e-mail message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions">\r
+            <summary>\r
+            Activate the options on this appender. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.SmtpPickupDirAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.SmtpPickupDirAppender.ConvertToFullPath(System.String)">\r
+            <summary>\r
+            Convert a path into a fully qualified path.\r
+            </summary>\r
+            <param name="path">The path to convert.</param>\r
+            <returns>The fully qualified path.</returns>\r
+            <remarks>\r
+            <para>\r
+            Converts the path specified to a fully\r
+            qualified path. If the path is relative it is\r
+            taken as relative from the application base \r
+            directory.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.SmtpPickupDirAppender.m_securityContext">\r
+            <summary>\r
+            The security context to use for privileged calls\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.To">\r
+            <summary>\r
+            Gets or sets a semicolon-delimited list of recipient e-mail addresses.\r
+            </summary>\r
+            <value>\r
+            A semicolon-delimited list of e-mail addresses.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            A semicolon-delimited list of e-mail addresses.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.From">\r
+            <summary>\r
+            Gets or sets the e-mail address of the sender.\r
+            </summary>\r
+            <value>\r
+            The e-mail address of the sender.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The e-mail address of the sender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.Subject">\r
+            <summary>\r
+            Gets or sets the subject line of the e-mail message.\r
+            </summary>\r
+            <value>\r
+            The subject line of the e-mail message.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The subject line of the e-mail message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.PickupDir">\r
+            <summary>\r
+            Gets or sets the path to write the messages to.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the path to write the messages to. This should be the same\r
+            as that used by the agent sending the messages.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> used to write to the pickup directory.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Unless a <see cref="P:log4net.Appender.SmtpPickupDirAppender.SecurityContext"/> specified here for this appender\r
+            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the\r
+            security context to use. The default behavior is to use the security context\r
+            of the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.SmtpPickupDirAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.TelnetAppender">\r
+            <summary>\r
+            Appender that allows clients to connect via Telnet to receive log messages\r
+            </summary>\r
+            <remarks>  \r
+            <para>\r
+            The TelnetAppender accepts socket connections and streams logging messages\r
+            back to the client.  \r
+            The output is provided in a telnet-friendly way so that a log can be monitored \r
+            over a TCP/IP socket.\r
+            This allows simple remote monitoring of application logging.\r
+            </para>\r
+            <para>\r
+            The default <see cref="P:log4net.Appender.TelnetAppender.Port"/> is 23 (the telnet port).\r
+            </para>\r
+            </remarks>\r
+            <author>Keith Long</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.TelnetAppender.declaringType">\r
+            <summary>\r
+            The fully qualified type of the TelnetAppender class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.OnClose">\r
+            <summary>\r
+            Overrides the parent method to close the socket handler\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Closes all the outstanding connections.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.ActivateOptions">\r
+            <summary>\r
+            Initialize the appender based on the options set.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Appender.TelnetAppender.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            Create the socket handler and wait for connections\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Writes the logging event to each connected client.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the logging event to each connected client.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TelnetAppender.Port">\r
+            <summary>\r
+            Gets or sets the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.\r
+            </summary>\r
+            <value>\r
+            An integer value in the range <see cref="F:System.Net.IPEndPoint.MinPort"/> to <see cref="F:System.Net.IPEndPoint.MaxPort"/> \r
+            indicating the TCP port number on which this <see cref="T:log4net.Appender.TelnetAppender"/> will listen for connections.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The default value is 23 (the telnet port).\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">The value specified is less than <see cref="F:System.Net.IPEndPoint.MinPort"/> \r
+            or greater than <see cref="F:System.Net.IPEndPoint.MaxPort"/>.</exception>\r
+        </member>\r
+        <member name="P:log4net.Appender.TelnetAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler">\r
+            <summary>\r
+            Helper class to manage connected clients\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The SocketHandler class is used to accept connections from\r
+            clients.  It is threaded so that clients can connect/disconnect\r
+            asynchronously.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.#ctor(System.Int32)">\r
+            <summary>\r
+            Opens a new server port on <paramref ref="port"/>\r
+            </summary>\r
+            <param name="port">the local port to listen on for connections</param>\r
+            <remarks>\r
+            <para>\r
+            Creates a socket handler on the specified local server port.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Send(System.String)">\r
+            <summary>\r
+            Sends a string message to each of the connected clients\r
+            </summary>\r
+            <param name="message">the text to send</param>\r
+            <remarks>\r
+            <para>\r
+            Sends a string message to each of the connected clients\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.AddClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">\r
+            <summary>\r
+            Add a client to the internal clients list\r
+            </summary>\r
+            <param name="client">client to add</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.RemoveClient(log4net.Appender.TelnetAppender.SocketHandler.SocketClient)">\r
+            <summary>\r
+            Remove a client from the internal clients list\r
+            </summary>\r
+            <param name="client">client to remove</param>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.OnConnect(System.IAsyncResult)">\r
+            <summary>\r
+            Callback used to accept a connection on the server socket\r
+            </summary>\r
+            <param name="asyncResult">The result of the asynchronous operation</param>\r
+            <remarks>\r
+            <para>\r
+            On connection adds to the list of connections \r
+            if there are two many open connections you will be disconnected\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.Dispose">\r
+            <summary>\r
+            Close all network connections\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Make sure we close all network connections\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TelnetAppender.SocketHandler.HasConnections">\r
+            <summary>\r
+            Test if this handler has active connections\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this handler has active connections\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This property will be <c>true</c> while this handler has\r
+            active connections, that is at least one connection that \r
+            the handler will attempt to send a message to.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient">\r
+            <summary>\r
+            Class that represents a client connected to this handler\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Class that represents a client connected to this handler\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.#ctor(System.Net.Sockets.Socket)">\r
+            <summary>\r
+            Create this <see cref="T:log4net.Appender.TelnetAppender.SocketHandler.SocketClient"/> for the specified <see cref="T:System.Net.Sockets.Socket"/>\r
+            </summary>\r
+            <param name="socket">the client's socket</param>\r
+            <remarks>\r
+            <para>\r
+            Opens a stream writer on the socket.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Send(System.String)">\r
+            <summary>\r
+            Write a string to the client\r
+            </summary>\r
+            <param name="message">string to send</param>\r
+            <remarks>\r
+            <para>\r
+            Write a string to the client\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TelnetAppender.SocketHandler.SocketClient.Dispose">\r
+            <summary>\r
+            Cleanup the clients connection\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Close the socket connection.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Appender.TraceAppender">\r
+            <summary>\r
+            Appends log events to the <see cref="T:System.Diagnostics.Trace"/> system.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The application configuration file can be used to control what listeners \r
+            are actually used. See the MSDN documentation for the \r
+            <see cref="T:System.Diagnostics.Trace"/> class for details on configuring the\r
+            trace system.\r
+            </para>\r
+            <para>\r
+            Events are written using the <c>System.Diagnostics.Trace.Write(string,string)</c>\r
+            method. The event's logger name is the default value for the category parameter \r
+            of the Write method. \r
+            </para>\r
+            <para>\r
+            <b>Compact Framework</b><br/>\r
+            The Compact Framework does not support the <see cref="T:System.Diagnostics.Trace"/>\r
+            class for any operation except <c>Assert</c>. When using the Compact Framework this\r
+            appender will write to the <see cref="T:System.Diagnostics.Debug"/> system rather than\r
+            the Trace system. This appender will therefore behave like the <see cref="T:log4net.Appender.DebugAppender"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Appender.TraceAppender.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TraceAppender.#ctor(log4net.Layout.ILayout)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Appender.TraceAppender"/> \r
+            with a specified layout.\r
+            </summary>\r
+            <param name="layout">The layout to use with this appender.</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Appender.TraceAppender.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the logging event to the <see cref="T:System.Diagnostics.Trace"/> system.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.TraceAppender.m_immediateFlush">\r
+            <summary>\r
+            Immediate flush means that the underlying writer or output stream\r
+            will be flushed at the end of each append operation.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Immediate flush is slower but ensures that each append request is \r
+            actually written. If <see cref="P:log4net.Appender.TraceAppender.ImmediateFlush"/> is set to\r
+            <c>false</c>, then there is a good chance that the last few\r
+            logs events are not actually written to persistent media if and\r
+            when the application crashes.\r
+            </para>\r
+            <para>\r
+            The default value is <c>true</c>.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Appender.TraceAppender.m_category">\r
+            <summary>\r
+            Defaults to %logger\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Appender.TraceAppender.ImmediateFlush">\r
+            <summary>\r
+            Gets or sets a value that indicates whether the appender will \r
+            flush at the end of each write.\r
+            </summary>\r
+            <remarks>\r
+            <para>The default behavior is to flush at the end of each \r
+            write. If the option is set to<c>false</c>, then the underlying \r
+            stream can defer writing to physical medium to a later time. \r
+            </para>\r
+            <para>\r
+            Avoiding the flush operation at the end of each append results \r
+            in a performance gain of 10 to 20 percent. However, there is safety\r
+            trade-off involved in skipping flushing. Indeed, when flushing is\r
+            skipped, then it is likely that the last few log events will not\r
+            be recorded on disk when the application exits. This is a high\r
+            price to pay even for a 20% performance gain.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TraceAppender.Category">\r
+            <summary>\r
+            The category parameter sent to the Trace method.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defaults to %logger which will use the logger name of the current \r
+            <see cref="T:log4net.Core.LoggingEvent"/> as the category parameter.\r
+            </para>\r
+            <para>\r
+            </para> \r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Appender.TraceAppender.RequiresLayout">\r
+            <summary>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            This appender requires a <see cref="N:log4net.Layout"/> to be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.AliasDomainAttribute">\r
+            <summary>\r
+            Assembly level attribute that specifies a domain to alias to this assembly's repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>\r
+            </para>\r
+            <para>\r
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.DomainAttribute"/>,\r
+            however this can be overridden by an assembly loaded before the target assembly.\r
+            </para>\r
+            <para>\r
+            An assembly can alias another assembly's domain to its repository by\r
+            specifying this attribute with the name of the target domain.\r
+            </para>\r
+            <para>\r
+            This attribute can only be specified on the assembly and may be used\r
+            as many times as necessary to alias all the required domains.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Config.AliasRepositoryAttribute">\r
+            <summary>\r
+            Assembly level attribute that specifies a repository to alias to this assembly's repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            An assembly's logger repository is defined by its <see cref="T:log4net.Config.RepositoryAttribute"/>,\r
+            however this can be overridden by an assembly loaded before the target assembly.\r
+            </para>\r
+            <para>\r
+            An assembly can alias another assembly's repository to its repository by\r
+            specifying this attribute with the name of the target repository.\r
+            </para>\r
+            <para>\r
+            This attribute can only be specified on the assembly and may be used\r
+            as many times as necessary to alias all the required repositories.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.AliasRepositoryAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with \r
+            the specified repository to alias to this assembly's repository.\r
+            </summary>\r
+            <param name="name">The repository to alias to this assemby's repository.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasRepositoryAttribute"/> class with \r
+            the specified repository to alias to this assembly's repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.AliasRepositoryAttribute.Name">\r
+            <summary>\r
+            Gets or sets the repository to alias to this assemby's repository.\r
+            </summary>\r
+            <value>\r
+            The repository to alias to this assemby's repository.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of the repository to alias to this assemby's repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.AliasDomainAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.AliasDomainAttribute"/> class with \r
+            the specified domain to alias to this assembly's repository.\r
+            </summary>\r
+            <param name="name">The domain to alias to this assemby's repository.</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete. Use <see cref="T:log4net.Config.AliasRepositoryAttribute"/> instead of <see cref="T:log4net.Config.AliasDomainAttribute"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.BasicConfigurator">\r
+            <summary>\r
+            Use this class to quickly configure a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Allows very simple programmatic configuration of log4net.\r
+            </para>\r
+            <para>\r
+            Only one appender can be configured using this configurator.\r
+            The appender is set at the root of the hierarchy and all logging\r
+            events will be delivered to that appender.\r
+            </para>\r
+            <para>\r
+            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore\r
+            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions()"/> method\r
+            be called after the appenders properties have been configured.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Config.BasicConfigurator.declaringType">\r
+            <summary>\r
+            The fully qualified type of the BasicConfigurator class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.BasicConfigurator"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.Configure">\r
+            <summary>\r
+            Initializes the log4net system with a default configuration.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes the log4net logging system using a <see cref="T:log4net.Appender.ConsoleAppender"/>\r
+            that will write to <c>Console.Out</c>. The log messages are\r
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object\r
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>\r
+            layout style.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Initializes the log4net system using the specified appender.\r
+            </summary>\r
+            <param name="appender">The appender to use to log all logging events.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes the log4net system using the specified appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Initializes the log4net system using the specified appenders.\r
+            </summary>\r
+            <param name="appenders">The appenders to use to log all logging events.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes the log4net system using the specified appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> with a default configuration.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes the specified repository using a <see cref="T:log4net.Appender.ConsoleAppender"/>\r
+            that will write to <c>Console.Out</c>. The log messages are\r
+            formatted using the <see cref="T:log4net.Layout.PatternLayout"/> layout object\r
+            with the <see cref="F:log4net.Layout.PatternLayout.DetailConversionPattern"/>\r
+            layout style.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender)">\r
+            <summary>\r
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="appender">The appender to use to log all logging events.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.BasicConfigurator.Configure(log4net.Repository.ILoggerRepository,log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appenders.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="appenders">The appenders to use to log all logging events.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.ConfiguratorAttribute">\r
+            <summary>\r
+            Base class for all log4net configuration attributes.\r
+            </summary>\r
+            <remarks>\r
+            This is an abstract class that must be extended by \r
+            specific configurators. This attribute allows the\r
+            configurator to be parameterized by an assembly level\r
+            attribute.\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.ConfiguratorAttribute.#ctor(System.Int32)">\r
+            <summary>\r
+            Constructor used by subclasses.\r
+            </summary>\r
+            <param name="priority">the ordering priority for this configurator</param>\r
+            <remarks>\r
+            <para>\r
+            The <paramref name="priority"/> is used to order the configurator\r
+            attributes before they are invoked. Higher priority configurators are executed\r
+            before lower priority ones.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.ConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.\r
+            </summary>\r
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>\r
+            <param name="targetRepository">The repository to configure.</param>\r
+            <remarks>\r
+            <para>\r
+            Abstract method implemented by a subclass. When this method is called\r
+            the subclass should configure the <paramref name="targetRepository"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.ConfiguratorAttribute.CompareTo(System.Object)">\r
+            <summary>\r
+            Compare this instance to another ConfiguratorAttribute\r
+            </summary>\r
+            <param name="obj">the object to compare to</param>\r
+            <returns>see <see cref="M:System.IComparable.CompareTo(System.Object)"/></returns>\r
+            <remarks>\r
+            <para>\r
+            Compares the priorities of the two <see cref="T:log4net.Config.ConfiguratorAttribute"/> instances.\r
+            Sorts by priority in descending order. Objects with the same priority are\r
+            randomly ordered.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.DomainAttribute">\r
+            <summary>\r
+            Assembly level attribute that specifies the logging domain for the assembly.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>DomainAttribute is obsolete. Use RepositoryAttribute instead of DomainAttribute.</b>\r
+            </para>\r
+            <para>\r
+            Assemblies are mapped to logging domains. Each domain has its own\r
+            logging repository. This attribute specified on the assembly controls\r
+            the configuration of the domain. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name\r
+            of the domain that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>\r
+            specifies the type of the repository objects to create for the domain. If \r
+            this attribute is not specified and a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> is not specified\r
+            then the assembly will be part of the default shared logging domain.\r
+            </para>\r
+            <para>\r
+            This attribute can only be specified on the assembly and may only be used\r
+            once per assembly.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Config.RepositoryAttribute">\r
+            <summary>\r
+            Assembly level attribute that specifies the logging repository for the assembly.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Assemblies are mapped to logging repository. This attribute specified \r
+            on the assembly controls\r
+            the configuration of the repository. The <see cref="P:log4net.Config.RepositoryAttribute.Name"/> property specifies the name\r
+            of the repository that this assembly is a part of. The <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/>\r
+            specifies the type of the <see cref="T:log4net.Repository.ILoggerRepository"/> object \r
+            to create for the assembly. If this attribute is not specified or a <see cref="P:log4net.Config.RepositoryAttribute.Name"/> \r
+            is not specified then the assembly will be part of the default shared logging repository.\r
+            </para>\r
+            <para>\r
+            This attribute can only be specified on the assembly and may only be used\r
+            once per assembly.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.RepositoryAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Initialize a new instance of the <see cref="T:log4net.Config.RepositoryAttribute"/> class \r
+            with the name of the repository.\r
+            </summary>\r
+            <param name="name">The name of the repository.</param>\r
+            <remarks>\r
+            <para>\r
+            Initialize the attribute with the name for the assembly's repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.RepositoryAttribute.Name">\r
+            <summary>\r
+            Gets or sets the name of the logging repository.\r
+            </summary>\r
+            <value>\r
+            The string name to use as the name of the repository associated with this\r
+            assembly.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This value does not have to be unique. Several assemblies can share the\r
+            same repository. They will share the logging configuration of the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.RepositoryAttribute.RepositoryType">\r
+            <summary>\r
+            Gets or sets the type of repository to create for this assembly.\r
+            </summary>\r
+            <value>\r
+            The type of repository to create for this assembly.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The type of the repository to create for the assembly.\r
+            The type must implement the <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            interface.\r
+            </para>\r
+            <para>\r
+            This will be the type of repository created when \r
+            the repository is created. If multiple assemblies reference the\r
+            same repository then the repository is only created once using the\r
+            <see cref="P:log4net.Config.RepositoryAttribute.RepositoryType"/> of the first assembly to call into the \r
+            repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DomainAttribute.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DomainAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Initialize a new instance of the <see cref="T:log4net.Config.DomainAttribute"/> class \r
+            with the name of the domain.\r
+            </summary>\r
+            <param name="name">The name of the domain.</param>\r
+            <remarks>\r
+            <para>\r
+            Obsolete. Use RepositoryAttribute instead of DomainAttribute.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.DOMConfigurator">\r
+            <summary>\r
+            Use this class to initialize the log4net environment using an Xml tree.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.#ctor">\r
+            <summary>\r
+            Private constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure">\r
+            <summary>\r
+            Automatically configures the log4net system based on the \r
+            application's configuration settings.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            Each application has a configuration file. This has the\r
+            same name as the application with '.config' appended.\r
+            This file is XML and calling this function prompts the\r
+            configurator to look in that file for a section called\r
+            <c>log4net</c> that contains the configuration data.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings\r
+            stored in the application's configuration file.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            Each application has a configuration file. This has the\r
+            same name as the application with '.config' appended.\r
+            This file is XML and calling this function prompts the\r
+            configurator to look in that file for a section called\r
+            <c>log4net</c> that contains the configuration data.\r
+            </remarks>\r
+            <param name="repository">The repository to configure.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.Xml.XmlElement)">\r
+            <summary>\r
+            Configures log4net using a <c>log4net</c> element\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            Loads the log4net configuration from the XML element\r
+            supplied as <paramref name="element"/>.\r
+            </remarks>\r
+            <param name="element">The element to parse.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML \r
+            element.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            Loads the log4net configuration from the XML element\r
+            supplied as <paramref name="element"/>.\r
+            </remarks>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="element">The element to parse.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.FileInfo)">\r
+            <summary>\r
+            Configures log4net using the specified configuration file.\r
+            </summary>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the log4net configuration data.\r
+            </para>\r
+            <para>\r
+            The log4net configuration file can possible be specified in the application's\r
+            configuration file (either <c>MyAppName.exe.config</c> for a\r
+            normal application on <c>Web.config</c> for an ASP.NET application).\r
+            </para>\r
+            <example>\r
+            The following example configures log4net using a configuration file, of which the \r
+            location is stored in the application's configuration file :\r
+            </example>\r
+            <code lang="C#">\r
+            using log4net.Config;\r
+            using System.IO;\r
+            using System.Configuration;\r
+            \r
+            ...\r
+            \r
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));\r
+            </code>\r
+            <para>\r
+            In the <c>.config</c> file, the path to the log4net can be specified like this :\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <appSettings>\r
+                       <add key="log4net-config-file" value="log.config"/>\r
+               </appSettings>\r
+            </configuration>\r
+            </code>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(System.IO.Stream)">\r
+            <summary>\r
+            Configures log4net using the specified configuration file.\r
+            </summary>\r
+            <param name="configStream">A stream to load the XML configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            The configuration data must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the log4net configuration data.\r
+            </para>\r
+            <para>\r
+            Note that this method will NOT close the stream parameter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration \r
+            file.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The log4net configuration file can possible be specified in the application's\r
+            configuration file (either <c>MyAppName.exe.config</c> for a\r
+            normal application on <c>Web.config</c> for an ASP.NET application).\r
+            </para>\r
+            <example>\r
+            The following example configures log4net using a configuration file, of which the \r
+            location is stored in the application's configuration file :\r
+            </example>\r
+            <code lang="C#">\r
+            using log4net.Config;\r
+            using System.IO;\r
+            using System.Configuration;\r
+            \r
+            ...\r
+            \r
+            DOMConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));\r
+            </code>\r
+            <para>\r
+            In the <c>.config</c> file, the path to the log4net can be specified like this :\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <appSettings>\r
+                       <add key="log4net-config-file" value="log.config"/>\r
+               </appSettings>\r
+            </configuration>\r
+            </code>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration \r
+            file.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configStream">The stream to load the XML configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            The configuration data must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            Note that this method will NOT close the stream parameter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(System.IO.FileInfo)">\r
+            <summary>\r
+            Configures log4net using the file specified, monitors the file for changes \r
+            and reloads the configuration if a change is detected.\r
+            </summary>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>\r
+            and depends on the behavior of that class.\r
+            </para>\r
+            <para>\r
+            For more information on how to configure log4net using\r
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Configure(FileInfo)"/>\r
+        </member>\r
+        <member name="M:log4net.Config.DOMConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, \r
+            monitors the file for changes and reloads the configuration if a change \r
+            is detected.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            <b>DOMConfigurator is obsolete. Use XmlConfigurator instead of DOMConfigurator.</b>\r
+            </para>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>\r
+            and depends on the behavior of that class.\r
+            </para>\r
+            <para>\r
+            For more information on how to configure log4net using\r
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Configure(FileInfo)"/>\r
+        </member>\r
+        <member name="T:log4net.Config.DOMConfiguratorAttribute">\r
+            <summary>\r
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>AliasDomainAttribute is obsolete. Use AliasRepositoryAttribute instead of AliasDomainAttribute.</b>\r
+            </para>\r
+            <para>\r
+            This attribute may only be used at the assembly scope and can only\r
+            be used once per assembly.\r
+            </para>\r
+            <para>\r
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>\r
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>\r
+            methods.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Config.XmlConfiguratorAttribute">\r
+            <summary>\r
+            Assembly level attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This attribute may only be used at the assembly scope and can only\r
+            be used once per assembly.\r
+            </para>\r
+            <para>\r
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>\r
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>\r
+            methods.\r
+            </para>\r
+            <para>\r
+            If neither of the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>\r
+            properties are set the configuration is loaded from the application's .config file.\r
+            If set the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property takes priority over the\r
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property. The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> property\r
+            specifies a path to a file to load the config from. The path is relative to the\r
+            application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.\r
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> property is used as a postfix to the assembly file name.\r
+            The config file must be located in the  application's base directory; <see cref="P:System.AppDomain.BaseDirectory"/>.\r
+            For example in a console application setting the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> to\r
+            <c>config</c> has the same effect as not specifying the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> or \r
+            <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> properties.\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.Watch"/> property can be set to cause the <see cref="T:log4net.Config.XmlConfigurator"/>\r
+            to watch the configuration file for changes.\r
+            </para>\r
+            <note>\r
+            <para>\r
+            Log4net will only look for assembly level configuration attributes once.\r
+            When using the log4net assembly level attributes to control the configuration \r
+            of log4net you must ensure that the first call to any of the \r
+            <see cref="T:log4net.Core.LoggerManager"/> methods is made from the assembly with the configuration\r
+            attributes. \r
+            </para>\r
+            <para>\r
+            If you cannot guarantee the order in which log4net calls will be made from \r
+            different assemblies you must use programmatic configuration instead, i.e.\r
+            call the <see cref="M:XmlConfigurator.Configure()"/> method directly.\r
+            </para>\r
+            </note>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.\r
+            </summary>\r
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>\r
+            <param name="targetRepository">The repository to configure.</param>\r
+            <remarks>\r
+            <para>\r
+            Configure the repository using the <see cref="T:log4net.Config.XmlConfigurator"/>.\r
+            The <paramref name="targetRepository"/> specified must extend the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>\r
+            class otherwise the <see cref="T:log4net.Config.XmlConfigurator"/> will not be able to\r
+            configure it.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="targetRepository"/> does not extend <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Attempt to load configuration from the local file system\r
+            </summary>\r
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>\r
+            <param name="targetRepository">The repository to configure.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromFile(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">\r
+            <summary>\r
+            Configure the specified repository using a <see cref="T:System.IO.FileInfo"/>\r
+            </summary>\r
+            <param name="targetRepository">The repository to configure.</param>\r
+            <param name="configFile">the FileInfo pointing to the config file</param>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfiguratorAttribute.ConfigureFromUri(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Attempt to load configuration from a URI\r
+            </summary>\r
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>\r
+            <param name="targetRepository">The repository to configure.</param>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfiguratorAttribute.declaringType">\r
+            <summary>\r
+            The fully qualified type of the XmlConfiguratorAttribute class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile">\r
+            <summary>\r
+            Gets or sets the filename of the configuration file.\r
+            </summary>\r
+            <value>\r
+            The filename of the configuration file.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If specified, this is the name of the configuration file to use with\r
+            the <see cref="T:log4net.Config.XmlConfigurator"/>. This file path is relative to the\r
+            <b>application base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>).\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension">\r
+            <summary>\r
+            Gets or sets the extension of the configuration file.\r
+            </summary>\r
+            <value>\r
+            The extension of the configuration file.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If specified this is the extension for the configuration file.\r
+            The path to the config file is built by using the <b>application \r
+            base</b> directory (<see cref="P:System.AppDomain.BaseDirectory"/>),\r
+            the <b>assembly file name</b> and the config file extension.\r
+            </para>\r
+            <para>\r
+            If the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/> is set to <c>MyExt</c> then\r
+            possible config file names would be: <c>MyConsoleApp.exe.MyExt</c> or\r
+            <c>MyClassLibrary.dll.MyExt</c>.\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFile"/> takes priority over the <see cref="P:log4net.Config.XmlConfiguratorAttribute.ConfigFileExtension"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.XmlConfiguratorAttribute.Watch">\r
+            <summary>\r
+            Gets or sets a value indicating whether to watch the configuration file.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if the configuration should be watched, <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If this flag is specified and set to <c>true</c> then the framework\r
+            will watch the configuration file and will reload the config each time \r
+            the file is modified.\r
+            </para>\r
+            <para>\r
+            The config file can only be watched if it is loaded from local disk.\r
+            In a No-Touch (Smart Client) deployment where the application is downloaded\r
+            from a web server the config file may not reside on the local disk\r
+            and therefore it may not be able to watch it.\r
+            </para>\r
+            <note>\r
+            Watching configuration is not supported on the SSCLI.\r
+            </note>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.Log4NetConfigurationSectionHandler">\r
+            <summary>\r
+            Class to register for the log4net section of the configuration file\r
+            </summary>\r
+            <remarks>\r
+            The log4net section of the configuration file needs to have a section\r
+            handler registered. This is the section handler used. It simply returns\r
+            the XML element that is the root of the section.\r
+            </remarks>\r
+            <example>\r
+            Example of registering the log4net section handler :\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <configSections>\r
+                       <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />\r
+               </configSections>\r
+               <log4net>\r
+                       log4net configuration XML goes here\r
+               </log4net>\r
+            </configuration>\r
+            </code>\r
+            </example>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.Log4NetConfigurationSectionHandler.Create(System.Object,System.Object,System.Xml.XmlNode)">\r
+            <summary>\r
+            Parses the configuration section.\r
+            </summary>\r
+            <param name="parent">The configuration settings in a corresponding parent configuration section.</param>\r
+            <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>\r
+            <param name="section">The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</param>\r
+            <returns>The <see cref="T:System.Xml.XmlNode"/> for the log4net section.</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the <see cref="T:System.Xml.XmlNode"/> containing the configuration data,\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.PluginAttribute">\r
+            <summary>\r
+            Assembly level attribute that specifies a plugin to attach to \r
+            the repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Specifies the type of a plugin to create and attach to the\r
+            assembly's repository. The plugin type must implement the\r
+            <see cref="T:log4net.Plugin.IPlugin"/> interface.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Plugin.IPluginFactory">\r
+            <summary>\r
+            Interface used to create plugins.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface used to create  a plugin.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Plugin.IPluginFactory.CreatePlugin">\r
+            <summary>\r
+            Creates the plugin object.\r
+            </summary>\r
+            <returns>the new plugin instance</returns>\r
+            <remarks>\r
+            <para>\r
+            Create and return a new plugin instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class\r
+            with the specified type.\r
+            </summary>\r
+            <param name="typeName">The type name of plugin to create.</param>\r
+            <remarks>\r
+            <para>\r
+            Create the attribute with the plugin type specified.\r
+            </para>\r
+            <para>\r
+            Where possible use the constructor that takes a <see cref="T:System.Type"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.PluginAttribute.#ctor(System.Type)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.PluginAttribute"/> class\r
+            with the specified type.\r
+            </summary>\r
+            <param name="type">The type of plugin to create.</param>\r
+            <remarks>\r
+            <para>\r
+            Create the attribute with the plugin type specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.PluginAttribute.CreatePlugin">\r
+            <summary>\r
+            Creates the plugin object defined by this attribute.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Creates the instance of the <see cref="T:log4net.Plugin.IPlugin"/> object as \r
+            specified by this attribute.\r
+            </para>\r
+            </remarks>\r
+            <returns>The plugin object.</returns>\r
+        </member>\r
+        <member name="M:log4net.Config.PluginAttribute.ToString">\r
+            <summary>\r
+            Returns a representation of the properties of this object.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Overrides base class <see cref="M:Object.ToString()" /> method to \r
+            return a representation of the properties of this object.\r
+            </para>\r
+            </remarks>\r
+            <returns>A representation of the properties of this object</returns>\r
+        </member>\r
+        <member name="P:log4net.Config.PluginAttribute.Type">\r
+            <summary>\r
+            Gets or sets the type for the plugin.\r
+            </summary>\r
+            <value>\r
+            The type for the plugin.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The type for the plugin.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.PluginAttribute.TypeName">\r
+            <summary>\r
+            Gets or sets the type name for the plugin.\r
+            </summary>\r
+            <value>\r
+            The type name for the plugin.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The type name for the plugin.\r
+            </para>\r
+            <para>\r
+            Where possible use the <see cref="P:log4net.Config.PluginAttribute.Type"/> property instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.SecurityContextProviderAttribute">\r
+            <summary>\r
+            Assembly level attribute to configure the <see cref="T:log4net.Core.SecurityContextProvider"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This attribute may only be used at the assembly scope and can only\r
+            be used once per assembly.\r
+            </para>\r
+            <para>\r
+            Use this attribute to configure the <see cref="T:log4net.Config.XmlConfigurator"/>\r
+            without calling one of the <see cref="M:XmlConfigurator.Configure()"/>\r
+            methods.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.#ctor(System.Type)">\r
+            <summary>\r
+            Construct provider attribute with type specified\r
+            </summary>\r
+            <param name="providerType">the type of the provider to use</param>\r
+            <remarks>\r
+            <para>\r
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>\r
+            class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.SecurityContextProviderAttribute.Configure(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Configures the SecurityContextProvider\r
+            </summary>\r
+            <param name="sourceAssembly">The assembly that this attribute was defined on.</param>\r
+            <param name="targetRepository">The repository to configure.</param>\r
+            <remarks>\r
+            <para>\r
+            Creates a provider instance from the <see cref="P:log4net.Config.SecurityContextProviderAttribute.ProviderType"/> specified.\r
+            Sets this as the default security context provider <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Config.SecurityContextProviderAttribute.declaringType">\r
+            <summary>\r
+            The fully qualified type of the SecurityContextProviderAttribute class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Config.SecurityContextProviderAttribute.ProviderType">\r
+            <summary>\r
+            Gets or sets the type of the provider to use.\r
+            </summary>\r
+            <value>\r
+            the type of the provider to use.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The provider specified must subclass the <see cref="T:log4net.Core.SecurityContextProvider"/>\r
+            class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.XmlConfigurator">\r
+            <summary>\r
+            Use this class to initialize the log4net environment using an Xml tree.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Configures a <see cref="T:log4net.Repository.ILoggerRepository"/> using an Xml tree.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.#ctor">\r
+            <summary>\r
+            Private constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure">\r
+            <summary>\r
+            Automatically configures the log4net system based on the \r
+            application's configuration settings.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Each application has a configuration file. This has the\r
+            same name as the application with '.config' appended.\r
+            This file is XML and calling this function prompts the\r
+            configurator to look in that file for a section called\r
+            <c>log4net</c> that contains the configuration data.\r
+            </para>\r
+            <para>\r
+            To use this method to configure log4net you must specify \r
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section\r
+            handler for the <c>log4net</c> configuration section. See the\r
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Automatically configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using settings\r
+            stored in the application's configuration file.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Each application has a configuration file. This has the\r
+            same name as the application with '.config' appended.\r
+            This file is XML and calling this function prompts the\r
+            configurator to look in that file for a section called\r
+            <c>log4net</c> that contains the configuration data.\r
+            </para>\r
+            <para>\r
+            To use this method to configure log4net you must specify \r
+            the <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> section\r
+            handler for the <c>log4net</c> configuration section. See the\r
+            <see cref="T:log4net.Config.Log4NetConfigurationSectionHandler"/> for an example.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The repository to configure.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Xml.XmlElement)">\r
+            <summary>\r
+            Configures log4net using a <c>log4net</c> element\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Loads the log4net configuration from the XML element\r
+            supplied as <paramref name="element"/>.\r
+            </para>\r
+            </remarks>\r
+            <param name="element">The element to parse.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified XML \r
+            element.\r
+            </summary>\r
+            <remarks>\r
+            Loads the log4net configuration from the XML element\r
+            supplied as <paramref name="element"/>.\r
+            </remarks>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="element">The element to parse.</param>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.FileInfo)">\r
+            <summary>\r
+            Configures log4net using the specified configuration file.\r
+            </summary>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the log4net configuration data.\r
+            </para>\r
+            <para>\r
+            The log4net configuration file can possible be specified in the application's\r
+            configuration file (either <c>MyAppName.exe.config</c> for a\r
+            normal application on <c>Web.config</c> for an ASP.NET application).\r
+            </para>\r
+            <para>\r
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the \r
+            configuration. If this file is also a .NET .config file then you must specify \r
+            a configuration section for the <c>log4net</c> element otherwise .NET will \r
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:\r
+            <code lang="XML" escaped="true">\r
+            <configSections>\r
+               <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>\r
+            </configSections>\r
+            </code>\r
+            </para>\r
+            <example>\r
+            The following example configures log4net using a configuration file, of which the \r
+            location is stored in the application's configuration file :\r
+            </example>\r
+            <code lang="C#">\r
+            using log4net.Config;\r
+            using System.IO;\r
+            using System.Configuration;\r
+            \r
+            ...\r
+            \r
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));\r
+            </code>\r
+            <para>\r
+            In the <c>.config</c> file, the path to the log4net can be specified like this :\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <appSettings>\r
+                       <add key="log4net-config-file" value="log.config"/>\r
+               </appSettings>\r
+            </configuration>\r
+            </code>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.Uri)">\r
+            <summary>\r
+            Configures log4net using the specified configuration URI.\r
+            </summary>\r
+            <param name="configUri">A URI to load the XML configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration data must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the log4net configuration data.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(System.IO.Stream)">\r
+            <summary>\r
+            Configures log4net using the specified configuration data stream.\r
+            </summary>\r
+            <param name="configStream">A stream to load the XML configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration data must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the log4net configuration data.\r
+            </para>\r
+            <para>\r
+            Note that this method will NOT close the stream parameter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration \r
+            file.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The log4net configuration file can possible be specified in the application's\r
+            configuration file (either <c>MyAppName.exe.config</c> for a\r
+            normal application on <c>Web.config</c> for an ASP.NET application).\r
+            </para>\r
+            <para>\r
+            The first element matching <c>&lt;configuration&gt;</c> will be read as the \r
+            configuration. If this file is also a .NET .config file then you must specify \r
+            a configuration section for the <c>log4net</c> element otherwise .NET will \r
+            complain. Set the type for the section handler to <see cref="T:System.Configuration.IgnoreSectionHandler"/>, for example:\r
+            <code lang="XML" escaped="true">\r
+            <configSections>\r
+               <section name="log4net" type="System.Configuration.IgnoreSectionHandler"/>\r
+            </configSections>\r
+            </code>\r
+            </para>\r
+            <example>\r
+            The following example configures log4net using a configuration file, of which the \r
+            location is stored in the application's configuration file :\r
+            </example>\r
+            <code lang="C#">\r
+            using log4net.Config;\r
+            using System.IO;\r
+            using System.Configuration;\r
+            \r
+            ...\r
+            \r
+            XmlConfigurator.Configure(new FileInfo(ConfigurationSettings.AppSettings["log4net-config-file"]));\r
+            </code>\r
+            <para>\r
+            In the <c>.config</c> file, the path to the log4net can be specified like this :\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <appSettings>\r
+                       <add key="log4net-config-file" value="log.config"/>\r
+               </appSettings>\r
+            </configuration>\r
+            </code>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.Uri)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration \r
+            URI.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configUri">A URI to load the XML configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration data must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:System.Net.WebRequest"/> must support the URI scheme specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.Configure(log4net.Repository.ILoggerRepository,System.IO.Stream)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the specified configuration \r
+            file.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configStream">The stream to load the XML configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration data must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            Note that this method will NOT close the stream parameter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(System.IO.FileInfo)">\r
+            <summary>\r
+            Configures log4net using the file specified, monitors the file for changes \r
+            and reloads the configuration if a change is detected.\r
+            </summary>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>\r
+            and depends on the behavior of that class.\r
+            </para>\r
+            <para>\r
+            For more information on how to configure log4net using\r
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Configure(FileInfo)"/>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatch(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">\r
+            <summary>\r
+            Configures the <see cref="T:log4net.Repository.ILoggerRepository"/> using the file specified, \r
+            monitors the file for changes and reloads the configuration if a change \r
+            is detected.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configFile">The XML file to load the configuration from.</param>\r
+            <remarks>\r
+            <para>\r
+            The configuration file must be valid XML. It must contain\r
+            at least one element called <c>log4net</c> that holds\r
+            the configuration data.\r
+            </para>\r
+            <para>\r
+            The configuration file will be monitored using a <see cref="T:System.IO.FileSystemWatcher"/>\r
+            and depends on the behavior of that class.\r
+            </para>\r
+            <para>\r
+            For more information on how to configure log4net using\r
+            a separate configuration file, see <see cref="M:Configure(FileInfo)"/>.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Configure(FileInfo)"/>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.InternalConfigureFromXml(log4net.Repository.ILoggerRepository,System.Xml.XmlElement)">\r
+            <summary>\r
+            Configures the specified repository using a <c>log4net</c> element.\r
+            </summary>\r
+            <param name="repository">The hierarchy to configure.</param>\r
+            <param name="element">The element to parse.</param>\r
+            <remarks>\r
+            <para>\r
+            Loads the log4net configuration from the XML element\r
+            supplied as <paramref name="element"/>.\r
+            </para>\r
+            <para>\r
+            This method is ultimately called by one of the Configure methods \r
+            to load the configuration from an <see cref="T:System.Xml.XmlElement"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.m_repositoryName2ConfigAndWatchHandler">\r
+            <summary>\r
+            Maps repository names to ConfigAndWatchHandler instances to allow a particular\r
+            ConfigAndWatchHandler to dispose of its FileSystemWatcher when a repository is \r
+            reconfigured.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.declaringType">\r
+            <summary>\r
+            The fully qualified type of the XmlConfigurator class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler">\r
+            <summary>\r
+            Class used to watch config files.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="T:System.IO.FileSystemWatcher"/> to monitor\r
+            changes to a specified file. Because multiple change notifications\r
+            may be raised when the file is modified, a timer is used to\r
+            compress the notifications into a single event. The timer\r
+            waits for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> time before delivering\r
+            the event notification. If any further <see cref="T:System.IO.FileSystemWatcher"/>\r
+            change notifications arrive while the timer is waiting it\r
+            is reset and waits again for <see cref="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis"/> to\r
+            elapse.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.TimeoutMillis">\r
+            <summary>\r
+            The default amount of time to wait after receiving notification\r
+            before reloading the config file.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_configFile">\r
+            <summary>\r
+            Holds the FileInfo used to configure the XmlConfigurator\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_repository">\r
+            <summary>\r
+            Holds the repository being configured.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_timer">\r
+            <summary>\r
+            The timer used to compress the notification events.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.m_watcher">\r
+            <summary>\r
+            Watches file for changes. This object should be disposed when no longer\r
+            needed to free system handles on the watched resources.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.#ctor(log4net.Repository.ILoggerRepository,System.IO.FileInfo)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class to\r
+            watch a specified config file used to configure a repository.\r
+            </summary>\r
+            <param name="repository">The repository to configure.</param>\r
+            <param name="configFile">The configuration file to watch.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnChanged(System.Object,System.IO.FileSystemEventArgs)">\r
+            <summary>\r
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.\r
+            </summary>\r
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>\r
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>\r
+            <remarks>\r
+            <para>\r
+            This handler reloads the configuration from the file when the event is fired.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.ConfigureAndWatchHandler_OnRenamed(System.Object,System.IO.RenamedEventArgs)">\r
+            <summary>\r
+            Event handler used by <see cref="T:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler"/>.\r
+            </summary>\r
+            <param name="source">The <see cref="T:System.IO.FileSystemWatcher"/> firing the event.</param>\r
+            <param name="e">The argument indicates the file that caused the event to be fired.</param>\r
+            <remarks>\r
+            <para>\r
+            This handler reloads the configuration from the file when the event is fired.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.OnWatchedFileChange(System.Object)">\r
+            <summary>\r
+            Called by the timer when the configuration has been updated.\r
+            </summary>\r
+            <param name="state">null</param>\r
+        </member>\r
+        <member name="M:log4net.Config.XmlConfigurator.ConfigureAndWatchHandler.Dispose">\r
+            <summary>\r
+            Release the handles held by the watcher and timer.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.CompactRepositorySelector">\r
+            <summary>\r
+            The implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface suitable\r
+            for use with the compact framework\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This <see cref="T:log4net.Core.IRepositorySelector"/> implementation is a simple\r
+            mapping between repository name and <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            object.\r
+            </para>\r
+            <para>\r
+            The .NET Compact Framework 1.0 does not support retrieving assembly\r
+            level attributes therefore unlike the <c>DefaultRepositorySelector</c>\r
+            this selector does not examine the calling assembly for attributes.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="T:log4net.Core.IRepositorySelector">\r
+            <summary>\r
+            Interface used by the <see cref="T:log4net.LogManager"/> to select the <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.LogManager"/> uses a <see cref="T:log4net.Core.IRepositorySelector"/> \r
+            to specify the policy for selecting the correct <see cref="T:log4net.Repository.ILoggerRepository"/> \r
+            to return to the caller.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.\r
+            </summary>\r
+            <param name="assembly">The assembly to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/></param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.\r
+            </para>\r
+            <para>\r
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            is made is not defined. The implementation may choose any method for\r
+            this association. The results of this method must be repeatable, i.e.\r
+            when called again with the same arguments the result must be the\r
+            save value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IRepositorySelector.GetRepository(System.String)">\r
+            <summary>\r
+            Gets the named <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </summary>\r
+            <param name="repositoryName">The name to use to lookup to the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>\r
+            <remarks>\r
+            Lookup a named <see cref="T:log4net.Repository.ILoggerRepository"/>. This is the repository created by\r
+            calling <see cref="M:CreateRepository(string,Type)"/>.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Creates a new repository for the assembly specified.\r
+            </summary>\r
+            <param name="assembly">The assembly to use to create the domain to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <returns>The repository created.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the domain\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            <para>\r
+            How the association between <see cref="T:System.Reflection.Assembly"/> and <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            is made is not defined. The implementation may choose any method for\r
+            this association.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IRepositorySelector.CreateRepository(System.String,System.Type)">\r
+            <summary>\r
+            Creates a new repository with the name specified.\r
+            </summary>\r
+            <param name="repositoryName">The name to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <returns>The repository created.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the name\r
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the\r
+            same name will return the same repository instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IRepositorySelector.ExistsRepository(System.String)">\r
+            <summary>\r
+            Test if a named repository exists\r
+            </summary>\r
+            <param name="repositoryName">the named repository to check</param>\r
+            <returns><c>true</c> if the repository exists</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if a named repository exists. Use <see cref="M:CreateRepository(Assembly, Type)"/>\r
+            to create a new repository and <see cref="M:GetRepository(Assembly)"/> to retrieve \r
+            a repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IRepositorySelector.GetAllRepositories">\r
+            <summary>\r
+            Gets an array of all currently defined repositories.\r
+            </summary>\r
+            <returns>\r
+            An array of the <see cref="T:log4net.Repository.ILoggerRepository"/> instances created by \r
+            this <see cref="T:log4net.Core.IRepositorySelector"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets an array of all of the repositories created by this selector.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent">\r
+            <summary>\r
+            Event to notify that a logger repository has been created.\r
+            </summary>\r
+            <value>\r
+            Event to notify that a logger repository has been created.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when a new repository is created.\r
+            The event source will be this selector. The event args will\r
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which\r
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.#ctor(System.Type)">\r
+            <summary>\r
+            Create a new repository selector\r
+            </summary>\r
+            <param name="defaultRepositoryType">the type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>\r
+            <remarks>\r
+            <para>\r
+            Create an new compact repository selector.\r
+            The default type for repositories must be specified,\r
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="defaultRepositoryType"/> is null</exception>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">throw if <paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/></exception>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Get the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly\r
+            </summary>\r
+            <param name="assembly">not used</param>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/></returns>\r
+            <remarks>\r
+            <para>\r
+            The <paramref name="assembly"/> argument is not used. This selector does not create a\r
+            separate repository for each assembly. \r
+            </para>\r
+            <para>\r
+            As a named repository is not specified the default repository is \r
+            returned. The default repository is named <c>log4net-default-repository</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.GetRepository(System.String)">\r
+            <summary>\r
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            </summary>\r
+            <param name="repositoryName">the name of the repository to lookup</param>\r
+            <returns>The named <see cref="T:log4net.Repository.ILoggerRepository"/></returns>\r
+            <remarks>\r
+            <para>\r
+            Get the named <see cref="T:log4net.Repository.ILoggerRepository"/>. The default \r
+            repository is <c>log4net-default-repository</c>. Other repositories \r
+            must be created using the <see cref="M:CreateRepository(string, Type)"/>.\r
+            If the named repository does not exist an exception is thrown.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>\r
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> does not exist</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Create a new repository for the assembly specified \r
+            </summary>\r
+            <param name="assembly">not used</param>\r
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>\r
+            <returns>the repository created</returns>\r
+            <remarks>\r
+            <para>\r
+            The <paramref name="assembly"/> argument is not used. This selector does not create a\r
+            separate repository for each assembly. \r
+            </para>\r
+            <para>\r
+            If the <paramref name="repositoryType"/> is <c>null</c> then the\r
+            default repository type specified to the constructor is used.\r
+            </para>\r
+            <para>\r
+            As a named repository is not specified the default repository is \r
+            returned. The default repository is named <c>log4net-default-repository</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.CreateRepository(System.String,System.Type)">\r
+            <summary>\r
+            Create a new repository for the repository specified\r
+            </summary>\r
+            <param name="repositoryName">the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/></param>\r
+            <param name="repositoryType">the type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            If this param is null then the default repository type is used.</param>\r
+            <returns>the repository created</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the\r
+            same repository specified will return the same repository instance.\r
+            </para>\r
+            <para>\r
+            If the named repository already exists an exception will be thrown.\r
+            </para>\r
+            <para>\r
+            If <paramref name="repositoryType"/> is <c>null</c> then the default \r
+            repository type specified to the constructor is used.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">throw if <paramref name="repositoryName"/> is null</exception>\r
+            <exception cref="T:log4net.Core.LogException">throw if the <paramref name="repositoryName"/> already exists</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.ExistsRepository(System.String)">\r
+            <summary>\r
+            Test if a named repository exists\r
+            </summary>\r
+            <param name="repositoryName">the named repository to check</param>\r
+            <returns><c>true</c> if the repository exists</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>\r
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve \r
+            a repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.GetAllRepositories">\r
+            <summary>\r
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects\r
+            </summary>\r
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets an array of all of the repositories created by this selector.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.CompactRepositorySelector.declaringType">\r
+            <summary>\r
+            The fully qualified type of the CompactRepositorySelector class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.CompactRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Notify the registered listeners that the repository has been created\r
+            </summary>\r
+            <param name="repository">The repository that has been created</param>\r
+            <remarks>\r
+            <para>\r
+            Raises the <event cref="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">LoggerRepositoryCreatedEvent</event>\r
+            event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Core.CompactRepositorySelector.LoggerRepositoryCreatedEvent">\r
+            <summary>\r
+            Event to notify that a logger repository has been created.\r
+            </summary>\r
+            <value>\r
+            Event to notify that a logger repository has been created.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when a new repository is created.\r
+            The event source will be this selector. The event args will\r
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which\r
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.DefaultRepositorySelector">\r
+            <summary>\r
+            The default implementation of the <see cref="T:log4net.Core.IRepositorySelector"/> interface.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses attributes defined on the calling assembly to determine how to\r
+            configure the hierarchy for the repository.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.#ctor(System.Type)">\r
+            <summary>\r
+            Creates a new repository selector.\r
+            </summary>\r
+            <param name="defaultRepositoryType">The type of the repositories to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/></param>\r
+            <remarks>\r
+            <para>\r
+            Create an new repository selector.\r
+            The default type for repositories must be specified,\r
+            an appropriate value would be <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="defaultRepositoryType"/> is <see langword="null"/>.</exception>\r
+            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="defaultRepositoryType"/> does not implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified assembly.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <remarks>\r
+            <para>\r
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and the repository \r
+            to create can be overridden by specifying the <see cref="T:log4net.Config.RepositoryAttribute"/> \r
+            attribute on the <paramref name="repositoryAssembly"/>.\r
+            </para>\r
+            <para>\r
+            The default values are to use the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> \r
+            implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the\r
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically configured using \r
+            any <see cref="T:log4net.Config.ConfiguratorAttribute"/> attributes defined on\r
+            the <paramref name="repositoryAssembly"/>.\r
+            </para>\r
+            </remarks>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the assembly</returns>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetRepository(System.String)">\r
+            <summary>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.\r
+            </summary>\r
+            <param name="repositoryName">The repository to use to lookup the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> for the specified repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the named repository. If <paramref name="repositoryName"/> is <c>null</c>\r
+            a <see cref="T:System.ArgumentNullException"/> is thrown. If the repository \r
+            does not exist a <see cref="T:log4net.Core.LogException"/> is thrown.\r
+            </para>\r
+            <para>\r
+            Use <see cref="M:CreateRepository(string, Type)"/> to create a repository.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>\r
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> does not exist.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Create a new repository for the assembly specified \r
+            </summary>\r
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <returns>The repository created.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            <para>\r
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and\r
+            the repository to create can be overridden by specifying the\r
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the \r
+            <paramref name="repositoryAssembly"/>.  The default values are to use the \r
+            <paramref name="repositoryType"/> implementation of the \r
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the\r
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically\r
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> \r
+            attributes defined on the <paramref name="repositoryAssembly"/>.\r
+            </para>\r
+            <para>\r
+            If a repository for the <paramref name="repositoryAssembly"/> already exists\r
+            that repository will be returned. An error will not be raised and that \r
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.\r
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the\r
+            assembly may be used to override the repository type specified in \r
+            <paramref name="repositoryType"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.Reflection.Assembly,System.Type,System.String,System.Boolean)">\r
+            <summary>\r
+            Creates a new repository for the assembly specified.\r
+            </summary>\r
+            <param name="repositoryAssembly">the assembly to use to create the repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <param name="repositoryName">The name to assign to the created repository</param>\r
+            <param name="readAssemblyAttributes">Set to <c>true</c> to read and apply the assembly attributes</param>\r
+            <returns>The repository created.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            <para>\r
+            The type of the <see cref="T:log4net.Repository.ILoggerRepository"/> created and\r
+            the repository to create can be overridden by specifying the\r
+            <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the \r
+            <paramref name="repositoryAssembly"/>.  The default values are to use the \r
+            <paramref name="repositoryType"/> implementation of the \r
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface and to use the\r
+            <see cref="P:System.Reflection.AssemblyName.Name"/> as the name of the repository.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be automatically\r
+            configured using any <see cref="T:log4net.Config.ConfiguratorAttribute"/> \r
+            attributes defined on the <paramref name="repositoryAssembly"/>.\r
+            </para>\r
+            <para>\r
+            If a repository for the <paramref name="repositoryAssembly"/> already exists\r
+            that repository will be returned. An error will not be raised and that \r
+            repository may be of a different type to that specified in <paramref name="repositoryType"/>.\r
+            Also the <see cref="T:log4net.Config.RepositoryAttribute"/> attribute on the\r
+            assembly may be used to override the repository type specified in \r
+            <paramref name="repositoryType"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryAssembly"/> is <see langword="null"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.CreateRepository(System.String,System.Type)">\r
+            <summary>\r
+            Creates a new repository for the specified repository.\r
+            </summary>\r
+            <param name="repositoryName">The repository to associate with the <see cref="T:log4net.Repository.ILoggerRepository"/>.</param>\r
+            <param name="repositoryType">The type of repository to create, must implement <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            If this param is <see langword="null"/> then the default repository type is used.</param>\r
+            <returns>The new repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(string)"/> with the\r
+            same repository specified will return the same repository instance.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="repositoryName"/> is <see langword="null"/>.</exception>\r
+            <exception cref="T:log4net.Core.LogException"><paramref name="repositoryName"/> already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.ExistsRepository(System.String)">\r
+            <summary>\r
+            Test if a named repository exists\r
+            </summary>\r
+            <param name="repositoryName">the named repository to check</param>\r
+            <returns><c>true</c> if the repository exists</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if a named repository exists. Use <see cref="M:CreateRepository(string, Type)"/>\r
+            to create a new repository and <see cref="M:GetRepository(string)"/> to retrieve \r
+            a repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetAllRepositories">\r
+            <summary>\r
+            Gets a list of <see cref="T:log4net.Repository.ILoggerRepository"/> objects\r
+            </summary>\r
+            <returns>an array of all known <see cref="T:log4net.Repository.ILoggerRepository"/> objects</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets an array of all of the repositories created by this selector.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.AliasRepository(System.String,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Aliases a repository to an existing repository.\r
+            </summary>\r
+            <param name="repositoryAlias">The repository to alias.</param>\r
+            <param name="repositoryTarget">The repository that the repository is aliased to.</param>\r
+            <remarks>\r
+            <para>\r
+            The repository specified will be aliased to the repository when created. \r
+            The repository must not already exist.\r
+            </para>\r
+            <para>\r
+            When the repository is created it must utilize the same repository type as \r
+            the repository it is aliased to, otherwise the aliasing will fail.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">\r
+            <para><paramref name="repositoryAlias"/> is <see langword="null"/>.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="repositoryTarget"/> is <see langword="null"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.OnLoggerRepositoryCreatedEvent(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Notifies the registered listeners that the repository has been created.\r
+            </summary>\r
+            <param name="repository">The repository that has been created.</param>\r
+            <remarks>\r
+            <para>\r
+            Raises the <see cref="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent"/> event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.GetInfoForAssembly(System.Reflection.Assembly,System.String@,System.Type@)">\r
+            <summary>\r
+            Gets the repository name and repository type for the specified assembly.\r
+            </summary>\r
+            <param name="assembly">The assembly that has a <see cref="T:log4net.Config.RepositoryAttribute"/>.</param>\r
+            <param name="repositoryName">in/out param to hold the repository name to use for the assembly, caller should set this to the default value before calling.</param>\r
+            <param name="repositoryType">in/out param to hold the type of the repository to create for the assembly, caller should set this to the default value before calling.</param>\r
+            <exception cref="T:System.ArgumentNullException"><paramref name="assembly"/> is <see langword="null"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.ConfigureRepository(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Configures the repository using information from the assembly.\r
+            </summary>\r
+            <param name="assembly">The assembly containing <see cref="T:log4net.Config.ConfiguratorAttribute"/>\r
+            attributes which define the configuration for the repository.</param>\r
+            <param name="repository">The repository to configure.</param>\r
+            <exception cref="T:System.ArgumentNullException">\r
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadPlugins(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Loads the attribute defined plugins on the assembly.\r
+            </summary>\r
+            <param name="assembly">The assembly that contains the attributes.</param>\r
+            <param name="repository">The repository to add the plugins to.</param>\r
+            <exception cref="T:System.ArgumentNullException">\r
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.DefaultRepositorySelector.LoadAliases(System.Reflection.Assembly,log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Loads the attribute defined aliases on the assembly.\r
+            </summary>\r
+            <param name="assembly">The assembly that contains the attributes.</param>\r
+            <param name="repository">The repository to alias to.</param>\r
+            <exception cref="T:System.ArgumentNullException">\r
+            <para><paramref name="assembly"/> is <see langword="null"/>.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="repository"/> is <see langword="null"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="F:log4net.Core.DefaultRepositorySelector.declaringType">\r
+            <summary>\r
+            The fully qualified type of the DefaultRepositorySelector class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Core.DefaultRepositorySelector.LoggerRepositoryCreatedEvent">\r
+            <summary>\r
+            Event to notify that a logger repository has been created.\r
+            </summary>\r
+            <value>\r
+            Event to notify that a logger repository has been created.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when a new repository is created.\r
+            The event source will be this selector. The event args will\r
+            be a <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> which\r
+            holds the newly created <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.ErrorCode">\r
+            <summary>\r
+            Defined error codes that can be passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Values passed to the <see cref="M:IErrorHandler.Error(string, Exception, ErrorCode)"/> method.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.GenericFailure">\r
+            <summary>\r
+            A general error\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.WriteFailure">\r
+            <summary>\r
+            Error while writing output\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.FlushFailure">\r
+            <summary>\r
+            Failed to flush file\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.CloseFailure">\r
+            <summary>\r
+            Failed to close file\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.FileOpenFailure">\r
+            <summary>\r
+            Unable to open output file\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.MissingLayout">\r
+            <summary>\r
+            No layout specified\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ErrorCode.AddressParseFailure">\r
+            <summary>\r
+            Failed to parse address\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.ExceptionEvaluator">\r
+            <summary>\r
+            An evaluator that triggers on an Exception type\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the type of the Exception\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is equal to a Type in <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.    /// \r
+            </para>\r
+            </remarks>\r
+            <author>Drew Schaeffer</author>\r
+        </member>\r
+        <member name="T:log4net.Core.ITriggeringEventEvaluator">\r
+            <summary>\r
+            Test if an <see cref="T:log4net.Core.LoggingEvent"/> triggers an action\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Implementations of this interface allow certain appenders to decide\r
+            when to perform an appender specific action.\r
+            </para>\r
+            <para>\r
+            The action or behavior triggered is defined by the implementation.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Core.ITriggeringEventEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Test if this event triggers the action\r
+            </summary>\r
+            <param name="loggingEvent">The event to check</param>\r
+            <returns><c>true</c> if this event triggers the action, otherwise <c>false</c></returns>\r
+            <remarks>\r
+            <para>\r
+            Return <c>true</c> if this event triggers the action\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.ExceptionEvaluator.m_type">\r
+            <summary>\r
+            The type that causes the trigger to fire.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.ExceptionEvaluator.m_triggerOnSubclass">\r
+            <summary>\r
+            Causes subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/> to cause the trigger to fire.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor">\r
+            <summary>\r
+            Default ctor to allow dynamic creation through a configurator.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.ExceptionEvaluator.#ctor(System.Type,System.Boolean)">\r
+            <summary>\r
+            Constructs an evaluator and initializes to trigger on <paramref name="exType"/>\r
+            </summary>\r
+            <param name="exType">the type that triggers this evaluator.</param>\r
+            <param name="triggerOnSubClass">If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.</param>\r
+        </member>\r
+        <member name="M:log4net.Core.ExceptionEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Is this <paramref name="loggingEvent"/> the triggering event?\r
+            </summary>\r
+            <param name="loggingEvent">The event to check</param>\r
+            <returns>This method returns <c>true</c>, if the logging event Exception \r
+            Type is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>. \r
+            Otherwise it returns <c>false</c></returns>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the Exception Type of the event\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.ExceptionEvaluator.ExceptionType">\r
+            <summary>\r
+            The type that triggers this evaluator.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.ExceptionEvaluator.TriggerOnSubclass">\r
+            <summary>\r
+            If true, this evaluator will trigger on subclasses of <see cref="P:log4net.Core.ExceptionEvaluator.ExceptionType"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.IErrorHandler">\r
+            <summary>\r
+            Appenders may delegate their error handling to an <see cref="T:log4net.Core.IErrorHandler"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Error handling is a particularly tedious to get right because by\r
+            definition errors are hard to predict and to reproduce. \r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">\r
+            <summary>\r
+            Handles the error and information about the error condition is passed as \r
+            a parameter.\r
+            </summary>\r
+            <param name="message">The message associated with the error.</param>\r
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>\r
+            <param name="errorCode">The error code associated with the error.</param>\r
+            <remarks>\r
+            <para>\r
+            Handles the error and information about the error condition is passed as \r
+            a parameter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String,System.Exception)">\r
+            <summary>\r
+            Prints the error message passed as a parameter.\r
+            </summary>\r
+            <param name="message">The message associated with the error.</param>\r
+            <param name="e">The <see cref="T:System.Exception"/> that was thrown when the error occurred.</param>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.IErrorHandler.Error(System.String)">\r
+            <summary>\r
+            Prints the error message passed as a parameter.\r
+            </summary>\r
+            <param name="message">The message associated with the error.</param>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="M:Error(string,Exception,ErrorCode)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.IFixingRequired">\r
+            <summary>\r
+            Interface for objects that require fixing.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface that indicates that the object requires fixing before it\r
+            can be taken outside the context of the appender's \r
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method.\r
+            </para>\r
+            <para>\r
+            When objects that implement this interface are stored \r
+            in the context properties maps <see cref="T:log4net.GlobalContext"/>\r
+            <see cref="P:log4net.GlobalContext.Properties"/> and <see cref="T:log4net.ThreadContext"/>\r
+            <see cref="P:log4net.ThreadContext.Properties"/> are fixed \r
+            (see <see cref="P:log4net.Core.LoggingEvent.Fix"/>) the <see cref="M:log4net.Core.IFixingRequired.GetFixedObject"/>\r
+            method will be called.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Core.IFixingRequired.GetFixedObject">\r
+            <summary>\r
+            Get a portable version of this object\r
+            </summary>\r
+            <returns>the portable instance of this object</returns>\r
+            <remarks>\r
+            <para>\r
+            Get a portable instance object that represents the current\r
+            state of this object. The portable object can be stored\r
+            and logged from any thread with identical results.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.ILogger">\r
+            <summary>\r
+            Interface that all loggers implement\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This interface supports logging events and testing if a level\r
+            is enabled for logging.\r
+            </para>\r
+            <para>\r
+            These methods will not throw exceptions. Note to implementor, ensure\r
+            that the implementation of these methods cannot allow an exception\r
+            to be thrown to the caller.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.ILogger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">\r
+            <summary>\r
+            This generic form is intended to be used by wrappers.\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <param name="level">The level of the message to be logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">the exception to log, including its stack trace. Pass <c>null</c> to not log an exception.</param>\r
+            <remarks>\r
+            <para>\r
+            Generates a logging event for the specified <paramref name="level"/> using\r
+            the <paramref name="message"/> and <paramref name="exception"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.ILogger.Log(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This is the most generic printing method that is intended to be used \r
+            by wrappers.\r
+            </summary>\r
+            <param name="logEvent">The event being logged.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs the specified logging event through this logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.ILogger.IsEnabledFor(log4net.Core.Level)">\r
+            <summary>\r
+            Checks if this logger is enabled for a given <see cref="T:log4net.Core.Level"/> passed as parameter.\r
+            </summary>\r
+            <param name="level">The level to check.</param>\r
+            <returns>\r
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Test if this logger is going to log events of the specified <paramref name="level"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.ILogger.Name">\r
+            <summary>\r
+            Gets the name of the logger.\r
+            </summary>\r
+            <value>\r
+            The name of the logger.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of this logger\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.ILogger.Repository">\r
+            <summary>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this \r
+            <c>Logger</c> instance is attached to.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this \r
+            <c>Logger</c> instance is attached to.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.ILoggerWrapper">\r
+            <summary>\r
+            Base interface for all wrappers\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Base interface for all wrappers.\r
+            </para>\r
+            <para>\r
+            All wrappers must implement this interface.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="P:log4net.Core.ILoggerWrapper.Logger">\r
+            <summary>\r
+            Get the implementation behind this wrapper object.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this object.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Core.ILogger"/> object that in implementing this\r
+            object. The <c>Logger</c> object may not \r
+            be the same object as this object because of logger decorators.\r
+            This gets the actual underlying objects that is used to process\r
+            the log events.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventHandler">\r
+            <summary>\r
+            Delegate used to handle logger repository creation event notifications\r
+            </summary>\r
+            <param name="sender">The <see cref="T:log4net.Core.IRepositorySelector"/> which created the repository.</param>\r
+            <param name="e">The <see cref="T:log4net.Core.LoggerRepositoryCreationEventArgs"/> event args\r
+            that holds the <see cref="T:log4net.Repository.ILoggerRepository"/> instance that has been created.</param>\r
+            <remarks>\r
+            <para>\r
+            Delegate used to handle logger repository creation event notifications.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LoggerRepositoryCreationEventArgs">\r
+            <summary>\r
+            Provides data for the <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> event.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A <see cref="E:log4net.Core.IRepositorySelector.LoggerRepositoryCreatedEvent"/> \r
+            event is raised every time a <see cref="T:log4net.Repository.ILoggerRepository"/> is created.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggerRepositoryCreationEventArgs.m_repository">\r
+            <summary>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerRepositoryCreationEventArgs.#ctor(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified\r
+            </summary>\r
+            <param name="repository">the <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created</param>\r
+            <remarks>\r
+            <para>\r
+            Construct instance using <see cref="T:log4net.Repository.ILoggerRepository"/> specified\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggerRepositoryCreationEventArgs.LoggerRepository">\r
+            <summary>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that has been created\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.Level">\r
+            <summary>\r
+            Defines the default set of levels recognized by the system.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Each <see cref="T:log4net.Core.LoggingEvent"/> has an associated <see cref="T:log4net.Core.Level"/>.\r
+            </para>\r
+            <para>\r
+            Levels have a numeric <see cref="P:log4net.Core.Level.Value"/> that defines the relative \r
+            ordering between levels. Two Levels with the same <see cref="P:log4net.Core.Level.Value"/> \r
+            are deemed to be equivalent.\r
+            </para>\r
+            <para>\r
+            The levels that are recognized by log4net are set for each <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and each repository can have different levels defined. The levels are stored\r
+            in the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> on the repository. Levels are\r
+            looked up by name from the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>.\r
+            </para>\r
+            <para>\r
+            When logging at level INFO the actual level used is not <see cref="F:log4net.Core.Level.Info"/> but\r
+            the value of <c>LoggerRepository.LevelMap["INFO"]</c>. The default value for this is\r
+            <see cref="F:log4net.Core.Level.Info"/>, but this can be changed by reconfiguring the level map.\r
+            </para>\r
+            <para>\r
+            Each level has a <see cref="P:log4net.Core.Level.DisplayName"/> in addition to its <see cref="P:log4net.Core.Level.Name"/>. The \r
+            <see cref="P:log4net.Core.Level.DisplayName"/> is the string that is written into the output log. By default\r
+            the display name is the same as the level name, but this can be used to alias levels\r
+            or to localize the log output.\r
+            </para>\r
+            <para>\r
+            Some of the predefined levels recognized by the system are:\r
+            </para>\r
+            <list type="bullet">\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.Off"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.Fatal"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.Error"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.Warn"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.Info"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.Debug"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <description><see cref="F:log4net.Core.Level.All"/>.</description>\r
+               </item>\r
+            </list>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String,System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>\r
+            <param name="levelName">The string name of this level.</param>\r
+            <param name="displayName">The display name for this level. This may be localized or otherwise different from the name</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with\r
+            the specified level name and value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.#ctor(System.Int32,System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="level">Integer value for this level, higher values represent more severe levels.</param>\r
+            <param name="levelName">The string name of this level.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.Level"/> class with\r
+            the specified level name and value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.ToString">\r
+            <summary>\r
+            Returns the <see cref="T:System.String"/> representation of the current \r
+            <see cref="T:log4net.Core.Level"/>.\r
+            </summary>\r
+            <returns>\r
+            A <see cref="T:System.String"/> representation of the current <see cref="T:log4net.Core.Level"/>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the level <see cref="P:log4net.Core.Level.Name"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.Equals(System.Object)">\r
+            <summary>\r
+            Compares levels.\r
+            </summary>\r
+            <param name="o">The object to compare against.</param>\r
+            <returns><c>true</c> if the objects are equal.</returns>\r
+            <remarks>\r
+            <para>\r
+            Compares the levels of <see cref="T:log4net.Core.Level"/> instances, and \r
+            defers to base class if the target object is not a <see cref="T:log4net.Core.Level"/>\r
+            instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.GetHashCode">\r
+            <summary>\r
+            Returns a hash code\r
+            </summary>\r
+            <returns>A hash code for the current <see cref="T:log4net.Core.Level"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns a hash code suitable for use in hashing algorithms and data \r
+            structures like a hash table.\r
+            </para>\r
+            <para>\r
+            Returns the hash code of the level <see cref="P:log4net.Core.Level.Value"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.CompareTo(System.Object)">\r
+            <summary>\r
+            Compares this instance to a specified object and returns an \r
+            indication of their relative values.\r
+            </summary>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/> instance or <see langword="null"/> to compare with this instance.</param>\r
+            <returns>\r
+            A 32-bit signed integer that indicates the relative order of the \r
+            values compared. The return value has these meanings:\r
+            <list type="table">\r
+               <listheader>\r
+                       <term>Value</term>\r
+                       <description>Meaning</description>\r
+               </listheader>\r
+               <item>\r
+                       <term>Less than zero</term>\r
+                       <description>This instance is less than <paramref name="r"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <term>Zero</term>\r
+                       <description>This instance is equal to <paramref name="r"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <term>Greater than zero</term>\r
+                       <description>\r
+                               <para>This instance is greater than <paramref name="r"/>.</para>\r
+                               <para>-or-</para>\r
+                               <para><paramref name="r"/> is <see langword="null"/>.</para>\r
+                               </description>\r
+               </item>\r
+            </list>\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            <paramref name="r"/> must be an instance of <see cref="T:log4net.Core.Level"/> \r
+            or <see langword="null"/>; otherwise, an exception is thrown.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentException"><paramref name="r"/> is not a <see cref="T:log4net.Core.Level"/>.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.op_GreaterThan(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> \r
+            is greater than another specified <see cref="T:log4net.Core.Level"/>.\r
+            </summary>\r
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>\r
+            <returns>\r
+            <c>true</c> if <paramref name="l"/> is greater than \r
+            <paramref name="r"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.op_LessThan(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> \r
+            is less than another specified <see cref="T:log4net.Core.Level"/>.\r
+            </summary>\r
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>\r
+            <returns>\r
+            <c>true</c> if <paramref name="l"/> is less than \r
+            <paramref name="r"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.op_GreaterThanOrEqual(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> \r
+            is greater than or equal to another specified <see cref="T:log4net.Core.Level"/>.\r
+            </summary>\r
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>\r
+            <returns>\r
+            <c>true</c> if <paramref name="l"/> is greater than or equal to \r
+            <paramref name="r"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.op_LessThanOrEqual(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Returns a value indicating whether a specified <see cref="T:log4net.Core.Level"/> \r
+            is less than or equal to another specified <see cref="T:log4net.Core.Level"/>.\r
+            </summary>\r
+            <param name="l">A <see cref="T:log4net.Core.Level"/></param>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/></param>\r
+            <returns>\r
+            <c>true</c> if <paramref name="l"/> is less than or equal to \r
+            <paramref name="r"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.op_Equality(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> \r
+            objects have the same value.\r
+            </summary>\r
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>\r
+            <returns>\r
+            <c>true</c> if the value of <paramref name="l"/> is the same as the \r
+            value of <paramref name="r"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.op_Inequality(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Returns a value indicating whether two specified <see cref="T:log4net.Core.Level"/> \r
+            objects have different values.\r
+            </summary>\r
+            <param name="l">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>\r
+            <param name="r">A <see cref="T:log4net.Core.Level"/> or <see langword="null"/>.</param>\r
+            <returns>\r
+            <c>true</c> if the value of <paramref name="l"/> is different from\r
+            the value of <paramref name="r"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.Level.Compare(log4net.Core.Level,log4net.Core.Level)">\r
+            <summary>\r
+            Compares two specified <see cref="T:log4net.Core.Level"/> instances.\r
+            </summary>\r
+            <param name="l">The first <see cref="T:log4net.Core.Level"/> to compare.</param>\r
+            <param name="r">The second <see cref="T:log4net.Core.Level"/> to compare.</param>\r
+            <returns>\r
+            A 32-bit signed integer that indicates the relative order of the \r
+            two values compared. The return value has these meanings:\r
+            <list type="table">\r
+               <listheader>\r
+                       <term>Value</term>\r
+                       <description>Meaning</description>\r
+               </listheader>\r
+               <item>\r
+                       <term>Less than zero</term>\r
+                       <description><paramref name="l"/> is less than <paramref name="r"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <term>Zero</term>\r
+                       <description><paramref name="l"/> is equal to <paramref name="r"/>.</description>\r
+               </item>\r
+               <item>\r
+                       <term>Greater than zero</term>\r
+                       <description><paramref name="l"/> is greater than <paramref name="r"/>.</description>\r
+               </item>\r
+            </list>\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares two levels.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Off">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Off"/> level designates a higher level than all the rest.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Log4Net_Debug">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. \r
+            System unusable, emergencies.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Emergency">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Emergency"/> level designates very severe error events. \r
+            System unusable, emergencies.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Fatal">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Fatal"/> level designates very severe error events \r
+            that will presumably lead the application to abort.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Alert">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Alert"/> level designates very severe error events. \r
+            Take immediate action, alerts.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Critical">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Critical"/> level designates very severe error events. \r
+            Critical condition, critical.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Severe">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Severe"/> level designates very severe error events.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Error">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Error"/> level designates error events that might \r
+            still allow the application to continue running.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Warn">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Warn"/> level designates potentially harmful \r
+            situations.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Notice">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Notice"/> level designates informational messages \r
+            that highlight the progress of the application at the highest level.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Info">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Info"/> level designates informational messages that \r
+            highlight the progress of the application at coarse-grained level.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Debug">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Debug"/> level designates fine-grained informational \r
+            events that are most useful to debug an application.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Fine">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Fine"/> level designates fine-grained informational \r
+            events that are most useful to debug an application.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Trace">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Trace"/> level designates fine-grained informational \r
+            events that are most useful to debug an application.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Finer">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Finer"/> level designates fine-grained informational \r
+            events that are most useful to debug an application.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Verbose">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Verbose"/> level designates fine-grained informational \r
+            events that are most useful to debug an application.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.Finest">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.Finest"/> level designates fine-grained informational \r
+            events that are most useful to debug an application.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.Level.All">\r
+            <summary>\r
+            The <see cref="F:log4net.Core.Level.All"/> level designates the lowest level possible.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.Level.Name">\r
+            <summary>\r
+            Gets the name of this level.\r
+            </summary>\r
+            <value>\r
+            The name of this level.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the name of this level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.Level.Value">\r
+            <summary>\r
+            Gets the value of this level.\r
+            </summary>\r
+            <value>\r
+            The value of this level.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the value of this level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.Level.DisplayName">\r
+            <summary>\r
+            Gets the display name of this level.\r
+            </summary>\r
+            <value>\r
+            The display name of this level.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the display name of this level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LevelCollection">\r
+            <summary>\r
+            A strongly-typed collection of <see cref="T:log4net.Core.Level"/> objects.\r
+            </summary>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.ReadOnly(log4net.Core.LevelCollection)">\r
+            <summary>\r
+            Creates a read-only wrapper for a <c>LevelCollection</c> instance.\r
+            </summary>\r
+            <param name="list">list to create a readonly wrapper arround</param>\r
+            <returns>\r
+            A <c>LevelCollection</c> wrapper that is read-only.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <c>LevelCollection</c> class\r
+            that is empty and has the default initial capacity.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Int32)">\r
+            <summary>\r
+            Initializes a new instance of the <c>LevelCollection</c> class\r
+            that has the specified initial capacity.\r
+            </summary>\r
+            <param name="capacity">\r
+            The number of elements that the new <c>LevelCollection</c> is initially capable of storing.\r
+            </param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>LevelCollection</c> class\r
+            that contains elements copied from the specified <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="c">The <c>LevelCollection</c> whose elements are copied to the new collection.</param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.Level[])">\r
+            <summary>\r
+            Initializes a new instance of the <c>LevelCollection</c> class\r
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> array.\r
+            </summary>\r
+            <param name="a">The <see cref="T:log4net.Core.Level"/> array whose elements are copied to the new list.</param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.#ctor(System.Collections.ICollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>LevelCollection</c> class\r
+            that contains elements copied from the specified <see cref="T:log4net.Core.Level"/> collection.\r
+            </summary>\r
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements are copied to the new list.</param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.#ctor(log4net.Core.LevelCollection.Tag)">\r
+            <summary>\r
+            Allow subclasses to avoid our default constructors\r
+            </summary>\r
+            <param name="tag"></param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[])">\r
+            <summary>\r
+            Copies the entire <c>LevelCollection</c> to a one-dimensional\r
+            <see cref="T:log4net.Core.Level"/> array.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.CopyTo(log4net.Core.Level[],System.Int32)">\r
+            <summary>\r
+            Copies the entire <c>LevelCollection</c> to a one-dimensional\r
+            <see cref="T:log4net.Core.Level"/> array, starting at the specified index of the target array.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:log4net.Core.Level"/> array to copy to.</param>\r
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Add(log4net.Core.Level)">\r
+            <summary>\r
+            Adds a <see cref="T:log4net.Core.Level"/> to the end of the <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to be added to the end of the <c>LevelCollection</c>.</param>\r
+            <returns>The index at which the value has been added.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Clear">\r
+            <summary>\r
+            Removes all elements from the <c>LevelCollection</c>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Clone">\r
+            <summary>\r
+            Creates a shallow copy of the <see cref="T:log4net.Core.LevelCollection"/>.\r
+            </summary>\r
+            <returns>A new <see cref="T:log4net.Core.LevelCollection"/> with a shallow copy of the collection data.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Contains(log4net.Core.Level)">\r
+            <summary>\r
+            Determines whether a given <see cref="T:log4net.Core.Level"/> is in the <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to check for.</param>\r
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.IndexOf(log4net.Core.Level)">\r
+            <summary>\r
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Core.Level"/>\r
+            in the <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to locate in the <c>LevelCollection</c>.</param>\r
+            <returns>\r
+            The zero-based index of the first occurrence of <paramref name="item"/> \r
+            in the entire <c>LevelCollection</c>, if found; otherwise, -1.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Insert(System.Int32,log4net.Core.Level)">\r
+            <summary>\r
+            Inserts an element into the <c>LevelCollection</c> at the specified index.\r
+            </summary>\r
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>\r
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to insert.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Remove(log4net.Core.Level)">\r
+            <summary>\r
+            Removes the first occurrence of a specific <see cref="T:log4net.Core.Level"/> from the <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Core.Level"/> to remove from the <c>LevelCollection</c>.</param>\r
+            <exception cref="T:System.ArgumentException">\r
+            The specified <see cref="T:log4net.Core.Level"/> was not found in the <c>LevelCollection</c>.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.RemoveAt(System.Int32)">\r
+            <summary>\r
+            Removes the element at the specified index of the <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="index">The zero-based index of the element to remove.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.GetEnumerator">\r
+            <summary>\r
+            Returns an enumerator that can iterate through the <c>LevelCollection</c>.\r
+            </summary>\r
+            <returns>An <see cref="T:log4net.Core.LevelCollection.Enumerator"/> for the entire <c>LevelCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.LevelCollection)">\r
+            <summary>\r
+            Adds the elements of another <c>LevelCollection</c> to the current <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="x">The <c>LevelCollection</c> whose elements should be added to the end of the current <c>LevelCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.AddRange(log4net.Core.Level[])">\r
+            <summary>\r
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> array to the current <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="x">The <see cref="T:log4net.Core.Level"/> array whose elements should be added to the end of the <c>LevelCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.AddRange(System.Collections.ICollection)">\r
+            <summary>\r
+            Adds the elements of a <see cref="T:log4net.Core.Level"/> collection to the current <c>LevelCollection</c>.\r
+            </summary>\r
+            <param name="col">The <see cref="T:log4net.Core.Level"/> collection whose elements should be added to the end of the <c>LevelCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Core.LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.TrimToSize">\r
+            <summary>\r
+            Sets the capacity to the actual number of elements.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32)">\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="i"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.ValidateIndex(System.Int32,System.Boolean)">\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="i"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.Count">\r
+            <summary>\r
+            Gets the number of elements actually contained in the <c>LevelCollection</c>.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.IsSynchronized">\r
+            <summary>\r
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).\r
+            </summary>\r
+            <value>true if access to the ICollection is synchronized (thread-safe); otherwise, false.</value>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.SyncRoot">\r
+            <summary>\r
+            Gets an object that can be used to synchronize access to the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.Item(System.Int32)">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Core.Level"/> at the specified index.\r
+            </summary>\r
+            <param name="index">The zero-based index of the element to get or set.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Core.LevelCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.IsFixedSize">\r
+            <summary>\r
+            Gets a value indicating whether the collection has a fixed size.\r
+            </summary>\r
+            <value>true if the collection has a fixed size; otherwise, false. The default is false</value>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.IsReadOnly">\r
+            <summary>\r
+            Gets a value indicating whether the IList is read-only.\r
+            </summary>\r
+            <value>true if the collection is read-only; otherwise, false. The default is false</value>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.Capacity">\r
+            <summary>\r
+            Gets or sets the number of elements the <c>LevelCollection</c> can contain.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.LevelCollection.ILevelCollectionEnumerator">\r
+            <summary>\r
+            Supports type-safe iteration over a <see cref="T:log4net.Core.LevelCollection"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.MoveNext">\r
+            <summary>\r
+            Advances the enumerator to the next element in the collection.\r
+            </summary>\r
+            <returns>\r
+            <c>true</c> if the enumerator was successfully advanced to the next element; \r
+            <c>false</c> if the enumerator has passed the end of the collection.\r
+            </returns>\r
+            <exception cref="T:System.InvalidOperationException">\r
+            The collection was modified after the enumerator was created.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Reset">\r
+            <summary>\r
+            Sets the enumerator to its initial position, before the first element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.ILevelCollectionEnumerator.Current">\r
+            <summary>\r
+            Gets the current element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.LevelCollection.Tag">\r
+            <summary>\r
+            Type visible only to our subclasses\r
+            Used to access protected constructor\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LevelCollection.Tag.Default">\r
+            <summary>\r
+            A value\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.LevelCollection.Enumerator">\r
+            <summary>\r
+            Supports simple iteration over a <see cref="T:log4net.Core.LevelCollection"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Enumerator.#ctor(log4net.Core.LevelCollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>Enumerator</c> class.\r
+            </summary>\r
+            <param name="tc"></param>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Enumerator.MoveNext">\r
+            <summary>\r
+            Advances the enumerator to the next element in the collection.\r
+            </summary>\r
+            <returns>\r
+            <c>true</c> if the enumerator was successfully advanced to the next element; \r
+            <c>false</c> if the enumerator has passed the end of the collection.\r
+            </returns>\r
+            <exception cref="T:System.InvalidOperationException">\r
+            The collection was modified after the enumerator was created.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelCollection.Enumerator.Reset">\r
+            <summary>\r
+            Sets the enumerator to its initial position, before the first element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelCollection.Enumerator.Current">\r
+            <summary>\r
+            Gets the current element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.LevelEvaluator">\r
+            <summary>\r
+            An evaluator that triggers at a threshold level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the level of the event\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>\r
+            level.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Core.LevelEvaluator.m_threshold">\r
+            <summary>\r
+            The threshold for triggering\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelEvaluator.#ctor">\r
+            <summary>\r
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Create a new evaluator using the <see cref="F:log4net.Core.Level.Off"/> threshold.\r
+            </para>\r
+            <para>\r
+            This evaluator will trigger if the level of the event\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>\r
+            level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelEvaluator.#ctor(log4net.Core.Level)">\r
+            <summary>\r
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.\r
+            </summary>\r
+            <param name="threshold">the threshold to trigger at</param>\r
+            <remarks>\r
+            <para>\r
+            Create a new evaluator using the specified <see cref="T:log4net.Core.Level"/> threshold.\r
+            </para>\r
+            <para>\r
+            This evaluator will trigger if the level of the event\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>\r
+            level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Is this <paramref name="loggingEvent"/> the triggering event?\r
+            </summary>\r
+            <param name="loggingEvent">The event to check</param>\r
+            <returns>This method returns <c>true</c>, if the event level\r
+            is equal or higher than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>. \r
+            Otherwise it returns <c>false</c></returns>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the level of the event\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>\r
+            level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelEvaluator.Threshold">\r
+            <summary>\r
+            the threshold to trigger at\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Core.Level"/> that will cause this evaluator to trigger\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the level of the event\r
+            passed to <see cref="M:IsTriggeringEvent(LoggingEvent)"/>\r
+            is equal to or greater than the <see cref="P:log4net.Core.LevelEvaluator.Threshold"/>\r
+            level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LevelMap">\r
+            <summary>\r
+            Mapping between string name and Level object\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Mapping between string name and <see cref="T:log4net.Core.Level"/> object.\r
+            This mapping is held separately for each <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            The level name is case insensitive.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Core.LevelMap.m_mapName2Level">\r
+            <summary>\r
+            Mapping from level name to Level object. The\r
+            level name is case insensitive\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelMap.#ctor">\r
+            <summary>\r
+            Construct the level map\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Construct the level map.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelMap.Clear">\r
+            <summary>\r
+            Clear the internal maps of all levels\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clear the internal maps of all levels\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32)">\r
+            <summary>\r
+            Create a new Level and add it to the map\r
+            </summary>\r
+            <param name="name">the string to display for the Level</param>\r
+            <param name="value">the level value to give to the Level</param>\r
+            <remarks>\r
+            <para>\r
+            Create a new Level and add it to the map\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Add(string,int,string)"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelMap.Add(System.String,System.Int32,System.String)">\r
+            <summary>\r
+            Create a new Level and add it to the map\r
+            </summary>\r
+            <param name="name">the string to display for the Level</param>\r
+            <param name="value">the level value to give to the Level</param>\r
+            <param name="displayName">the display name to give to the Level</param>\r
+            <remarks>\r
+            <para>\r
+            Create a new Level and add it to the map\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelMap.Add(log4net.Core.Level)">\r
+            <summary>\r
+            Add a Level to the map\r
+            </summary>\r
+            <param name="level">the Level to add</param>\r
+            <remarks>\r
+            <para>\r
+            Add a Level to the map\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LevelMap.LookupWithDefault(log4net.Core.Level)">\r
+            <summary>\r
+            Lookup a named level from the map\r
+            </summary>\r
+            <param name="defaultLevel">the name of the level to lookup is taken from this level. \r
+            If the level is not set on the map then this level is added</param>\r
+            <returns>the level in the map with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Lookup a named level from the map. The name of the level to lookup is taken\r
+            from the <see cref="P:log4net.Core.Level.Name"/> property of the <paramref name="defaultLevel"/>\r
+            argument.\r
+            </para>\r
+            <para>\r
+            If no level with the specified name is found then the \r
+            <paramref name="defaultLevel"/> argument is added to the level map\r
+            and returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelMap.Item(System.String)">\r
+            <summary>\r
+            Lookup a <see cref="T:log4net.Core.Level"/> by name\r
+            </summary>\r
+            <param name="name">The name of the Level to lookup</param>\r
+            <returns>a Level from the map with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the <see cref="T:log4net.Core.Level"/> from the\r
+            map with the name specified. If the no level is\r
+            found then <c>null</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LevelMap.AllLevels">\r
+            <summary>\r
+            Return all possible levels as a list of Level objects.\r
+            </summary>\r
+            <returns>all possible levels as a list of Level objects</returns>\r
+            <remarks>\r
+            <para>\r
+            Return all possible levels as a list of Level objects.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LocationInfo">\r
+            <summary>\r
+            The internal representation of caller location information.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class uses the <c>System.Diagnostics.StackTrace</c> class to generate\r
+            a call stack. The caller's information is then extracted from this stack.\r
+            </para>\r
+            <para>\r
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the \r
+            .NET Compact Framework 1.0 therefore caller location information is not\r
+            available on that framework.\r
+            </para>\r
+            <para>\r
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:\r
+            </para>\r
+            <para>\r
+            "StackTrace information will be most informative with Debug build configurations. \r
+            By default, Debug builds include debug symbols, while Release builds do not. The \r
+            debug symbols contain most of the file, method name, line number, and column \r
+            information used in constructing StackFrame and StackTrace objects. StackTrace \r
+            might not report as many method calls as expected, due to code transformations \r
+            that occur during optimization."\r
+            </para>\r
+            <para>\r
+            This means that in a Release build the caller information may be incomplete or may \r
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Core.LocationInfo.NA">\r
+            <summary>\r
+            When location information is not available the constant\r
+            <c>NA</c> is returned. Current value of this string\r
+            constant is <b>?</b>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.Type)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>\r
+            class based on the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LocationInfo.#ctor(System.String,System.String,System.String,System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="className">The fully qualified class name.</param>\r
+            <param name="methodName">The method name.</param>\r
+            <param name="fileName">The file name.</param>\r
+            <param name="lineNumber">The line number of the method within the file.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LocationInfo"/>\r
+            class with the specified data.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LocationInfo.declaringType">\r
+            <summary>\r
+            The fully qualified type of the LocationInfo class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LocationInfo.ClassName">\r
+            <summary>\r
+            Gets the fully qualified class name of the caller making the logging \r
+            request.\r
+            </summary>\r
+            <value>\r
+            The fully qualified class name of the caller making the logging \r
+            request.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the fully qualified class name of the caller making the logging \r
+            request.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LocationInfo.FileName">\r
+            <summary>\r
+            Gets the file name of the caller.\r
+            </summary>\r
+            <value>\r
+            The file name of the caller.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the file name of the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LocationInfo.LineNumber">\r
+            <summary>\r
+            Gets the line number of the caller.\r
+            </summary>\r
+            <value>\r
+            The line number of the caller.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the line number of the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LocationInfo.MethodName">\r
+            <summary>\r
+            Gets the method name of the caller.\r
+            </summary>\r
+            <value>\r
+            The method name of the caller.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the method name of the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LocationInfo.FullInfo">\r
+            <summary>\r
+            Gets all available caller information\r
+            </summary>\r
+            <value>\r
+            All available caller information, in the format\r
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets all available caller information, in the format\r
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LocationInfo.StackFrames">\r
+            <summary>\r
+            Gets the stack frames from the stack trace of the caller making the log request\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Core.LoggerManager">\r
+            <summary>\r
+            Static manager that controls the creation of repositories\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Static manager that controls the creation of repositories\r
+            </para>\r
+            <para>\r
+            This class is used by the wrapper managers (e.g. <see cref="T:log4net.LogManager"/>)\r
+            to provide access to the <see cref="T:log4net.Core.ILogger"/> objects.\r
+            </para>\r
+            <para>\r
+            This manager also holds the <see cref="T:log4net.Core.IRepositorySelector"/> that is used to\r
+            lookup and create repositories. The selector can be set either programmatically using\r
+            the <see cref="P:log4net.Core.LoggerManager.RepositorySelector"/> property, or by setting the <c>log4net.RepositorySelector</c>\r
+            AppSetting in the applications config file to the fully qualified type name of the\r
+            selector to use. \r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.#ctor">\r
+            <summary>\r
+            Private constructor to prevent instances. Only static methods should be used.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Private constructor to prevent instances. Only static methods should be used.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.#cctor">\r
+            <summary>\r
+            Hook the shutdown event\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            On the full .NET runtime, the static constructor hooks up the \r
+            <c>AppDomain.ProcessExit</c> and <c>AppDomain.DomainUnload</c>> events. \r
+            These are used to shutdown the log4net system as the application exits.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.RegisterAppDomainEvents">\r
+            <summary>\r
+            Register for ProcessExit and DomainUnload events on the AppDomain\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This needs to be in a separate method because the events make\r
+            a LinkDemand for the ControlAppDomain SecurityPermission. Because\r
+            this is a LinkDemand it is demanded at JIT time. Therefore we cannot\r
+            catch the exception in the method itself, we have to catch it in the\r
+            caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.String)">\r
+            <summary>\r
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <param name="repository">the repository to lookup in</param>\r
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the <paramref name="repository"/> argument.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetLoggerRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.String)">\r
+            <summary>\r
+            Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <param name="repository">the repository to lookup in</param>\r
+            <returns>Return the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the <paramref name="repository"/> argument.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.Exists(System.String,System.String)">\r
+            <summary>\r
+            Returns the named logger if it exists.\r
+            </summary>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <param name="name">The fully qualified logger name to look for.</param>\r
+            <returns>\r
+            The logger found, or <c>null</c> if the named logger does not exist in the\r
+            specified repository.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            If the named logger exists (in the specified repository) then it\r
+            returns a reference to the logger, otherwise it returns\r
+            <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.Exists(System.Reflection.Assembly,System.String)">\r
+            <summary>\r
+            Returns the named logger if it exists.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <param name="name">The fully qualified logger name to look for.</param>\r
+            <returns>\r
+            The logger found, or <c>null</c> if the named logger does not exist in the\r
+            specified assembly's repository.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            If the named logger exists (in the specified assembly's repository) then it\r
+            returns a reference to the logger, otherwise it returns\r
+            <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.String)">\r
+            <summary>\r
+            Returns all the currently defined loggers in the specified repository.\r
+            </summary>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <returns>All the defined loggers.</returns>\r
+            <remarks>\r
+            <para>\r
+            The root logger is <b>not</b> included in the returned array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetCurrentLoggers(System.Reflection.Assembly)">\r
+            <summary>\r
+            Returns all the currently defined loggers in the specified assembly's repository.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <returns>All the defined loggers.</returns>\r
+            <remarks>\r
+            <para>\r
+            The root logger is <b>not</b> included in the returned array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.String)">\r
+            <summary>\r
+            Retrieves or creates a named logger.\r
+            </summary>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <param name="name">The name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+            <remarks>\r
+            <para>\r
+            Retrieves a logger named as the <paramref name="name"/>\r
+            parameter. If the named logger already exists, then the\r
+            existing instance will be returned. Otherwise, a new instance is\r
+            created.\r
+            </para>\r
+            <para>\r
+            By default, loggers do not have a set level but inherit\r
+            it from the hierarchy. This is one of the central features of\r
+            log4net.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.String)">\r
+            <summary>\r
+            Retrieves or creates a named logger.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <param name="name">The name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+            <remarks>\r
+            <para>\r
+            Retrieves a logger named as the <paramref name="name"/>\r
+            parameter. If the named logger already exists, then the\r
+            existing instance will be returned. Otherwise, a new instance is\r
+            created.\r
+            </para>\r
+            <para>\r
+            By default, loggers do not have a set level but inherit\r
+            it from the hierarchy. This is one of the central features of\r
+            log4net.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.String,System.Type)">\r
+            <summary>\r
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.\r
+            </summary>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the logger for the fully qualified name of the type specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetLogger(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.\r
+            </summary>\r
+            <param name="repositoryAssembly">the assembly to use to lookup the repository</param>\r
+            <param name="type">The <paramref name="type"/> of which the fullname will be used as the name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the logger for the fully qualified name of the type specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.Shutdown">\r
+            <summary>\r
+            Shuts down the log4net system.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in all the\r
+            default repositories.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>\r
+            The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.String)">\r
+            <summary>\r
+            Shuts down the repository for the repository specified.\r
+            </summary>\r
+            <param name="repository">The repository to shutdown.</param>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in the\r
+            repository for the <paramref name="repository"/> specified.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>\r
+            The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.ShutdownRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Shuts down the repository for the repository specified.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in the\r
+            repository for the repository. The repository is looked up using\r
+            the <paramref name="repositoryAssembly"/> specified.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>\r
+            The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.String)">\r
+            <summary>\r
+            Resets all values contained in this repository instance to their defaults.\r
+            </summary>\r
+            <param name="repository">The repository to reset.</param>\r
+            <remarks>\r
+            <para>\r
+            Resets all values contained in the repository instance to their\r
+            defaults.  This removes all appenders from all loggers, sets\r
+            the level of all non-root loggers to <c>null</c>,\r
+            sets their additivity flag to <c>true</c> and sets the level\r
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,\r
+            message disabling is set its default "off" value.\r
+            </para>            \r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.ResetConfiguration(System.Reflection.Assembly)">\r
+            <summary>\r
+            Resets all values contained in this repository instance to their defaults.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>\r
+            <remarks>\r
+            <para>\r
+            Resets all values contained in the repository instance to their\r
+            defaults.  This removes all appenders from all loggers, sets\r
+            the level of all non-root loggers to <c>null</c>,\r
+            sets their additivity flag to <c>true</c> and sets the level\r
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,\r
+            message disabling is set its default "off" value.\r
+            </para>            \r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String)">\r
+            <summary>\r
+            Creates a repository with the specified name.\r
+            </summary>\r
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a\r
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.\r
+            </para>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String)">\r
+            <summary>\r
+            Creates a repository with the specified name.\r
+            </summary>\r
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a\r
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.\r
+            </para>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.String,System.Type)">\r
+            <summary>\r
+            Creates a repository with the specified name and repository type.\r
+            </summary>\r
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An Exception will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.String,System.Type)">\r
+            <summary>\r
+            Creates a repository with the specified name and repository type.\r
+            </summary>\r
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An Exception will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.CreateDomain(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Creates a repository for the specified assembly and repository type.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.CreateRepository(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Creates a repository for the specified assembly and repository type.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetAllRepositories">\r
+            <summary>\r
+            Gets an array of all currently defined repositories.\r
+            </summary>\r
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets an array of all currently defined repositories.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.GetVersionInfo">\r
+            <summary>\r
+            Internal method to get pertinent version info.\r
+            </summary>\r
+            <returns>A string of version info.</returns>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.OnDomainUnload(System.Object,System.EventArgs)">\r
+            <summary>\r
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires\r
+            </summary>\r
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>\r
+            <param name="e">null</param>\r
+            <remarks>\r
+            <para>\r
+            Called when the <see cref="E:System.AppDomain.DomainUnload"/> event fires.\r
+            </para>\r
+            <para>\r
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerManager.OnProcessExit(System.Object,System.EventArgs)">\r
+            <summary>\r
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires\r
+            </summary>\r
+            <param name="sender">the <see cref="T:System.AppDomain"/> that is exiting</param>\r
+            <param name="e">null</param>\r
+            <remarks>\r
+            <para>\r
+            Called when the <see cref="E:System.AppDomain.ProcessExit"/> event fires.\r
+            </para>\r
+            <para>\r
+            When the event is triggered the log4net system is <see cref="M:Shutdown()"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggerManager.declaringType">\r
+            <summary>\r
+            The fully qualified type of the LoggerManager class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggerManager.s_repositorySelector">\r
+            <summary>\r
+            Initialize the default repository selector\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggerManager.RepositorySelector">\r
+            <summary>\r
+            Gets or sets the repository selector used by the <see cref="T:log4net.LogManager"/>.\r
+            </summary>\r
+            <value>\r
+            The repository selector used by the <see cref="T:log4net.LogManager"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The repository selector (<see cref="T:log4net.Core.IRepositorySelector"/>) is used by \r
+            the <see cref="T:log4net.LogManager"/> to create and select repositories \r
+            (<see cref="T:log4net.Repository.ILoggerRepository"/>).\r
+            </para>\r
+            <para>\r
+            The caller to <see cref="T:log4net.LogManager"/> supplies either a string name \r
+            or an assembly (if not supplied the assembly is inferred using \r
+            <see cref="M:Assembly.GetCallingAssembly()"/>).\r
+            </para>\r
+            <para>\r
+            This context is used by the selector to lookup a specific repository.\r
+            </para>\r
+            <para>\r
+            For the full .NET Framework, the default repository is <c>DefaultRepositorySelector</c>;\r
+            for the .NET Compact Framework <c>CompactRepositorySelector</c> is the default\r
+            repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LoggerWrapperImpl">\r
+            <summary>\r
+            Implementation of the <see cref="T:log4net.Core.ILoggerWrapper"/> interface.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class should be used as the base for all wrapper implementations.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggerWrapperImpl.#ctor(log4net.Core.ILogger)">\r
+            <summary>\r
+            Constructs a new wrapper for the specified logger.\r
+            </summary>\r
+            <param name="logger">The logger to wrap.</param>\r
+            <remarks>\r
+            <para>\r
+            Constructs a new wrapper for the specified logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggerWrapperImpl.m_logger">\r
+            <summary>\r
+            The logger that this object is wrapping\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggerWrapperImpl.Logger">\r
+            <summary>\r
+            Gets the implementation behind this wrapper object.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Core.ILogger"/> object that this object is implementing.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <c>Logger</c> object may not be the same object as this object \r
+            because of logger decorators.\r
+            </para>\r
+            <para>\r
+            This gets the actual underlying objects that is used to process\r
+            the log events.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LoggingEventData">\r
+            <summary>\r
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Portable data structure used by <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.LoggerName">\r
+            <summary>\r
+            The logger name.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The logger name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.Level">\r
+            <summary>\r
+            Level of logging event.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Level of logging event. Level cannot be Serializable\r
+            because it is a flyweight.  Due to its special serialization it\r
+            cannot be declared final either.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.Message">\r
+            <summary>\r
+            The application supplied message.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The application supplied message of logging event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.ThreadName">\r
+            <summary>\r
+            The name of thread\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The name of thread in which this logging event was generated\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.TimeStamp">\r
+            <summary>\r
+            The time the event was logged\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The TimeStamp is stored in the local time zone for this computer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.LocationInfo">\r
+            <summary>\r
+            Location information for the caller.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Location information for the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.UserName">\r
+            <summary>\r
+            String representation of the user\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            String representation of the user's windows name,\r
+            like DOMAIN\username\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.Identity">\r
+            <summary>\r
+            String representation of the identity.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            String representation of the current thread's principal identity.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.ExceptionString">\r
+            <summary>\r
+            The string representation of the exception\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The string representation of the exception\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.Domain">\r
+            <summary>\r
+            String representation of the AppDomain.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            String representation of the AppDomain.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEventData.Properties">\r
+            <summary>\r
+            Additional event specific properties\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A logger or an appender may attach additional\r
+            properties to specific events. These properties\r
+            have a string key and an object value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.FixFlags">\r
+            <summary>\r
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Flags passed to the <see cref="P:log4net.Core.LoggingEvent.Fix"/> property\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Mdc">\r
+            <summary>\r
+            Fix the MDC\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Ndc">\r
+            <summary>\r
+            Fix the NDC\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Message">\r
+            <summary>\r
+            Fix the rendered message\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.ThreadName">\r
+            <summary>\r
+            Fix the thread name\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.LocationInfo">\r
+            <summary>\r
+            Fix the callers location information\r
+            </summary>\r
+            <remarks>\r
+            CAUTION: Very slow to generate\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.UserName">\r
+            <summary>\r
+            Fix the callers windows user name\r
+            </summary>\r
+            <remarks>\r
+            CAUTION: Slow to generate\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Domain">\r
+            <summary>\r
+            Fix the domain friendly name\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Identity">\r
+            <summary>\r
+            Fix the callers principal name\r
+            </summary>\r
+            <remarks>\r
+            CAUTION: May be slow to generate\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Exception">\r
+            <summary>\r
+            Fix the exception text\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Properties">\r
+            <summary>\r
+            Fix the event properties. Active properties must implement <see cref="T:log4net.Core.IFixingRequired"/> in order to be eligible for fixing.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.None">\r
+            <summary>\r
+            No fields fixed\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.All">\r
+            <summary>\r
+            All fields fixed\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.FixFlags.Partial">\r
+            <summary>\r
+            Partial fields fixed\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This set of partial fields gives good performance. The following fields are fixed:\r
+            </para>\r
+            <list type="bullet">\r
+            <item><description><see cref="F:log4net.Core.FixFlags.Message"/></description></item>\r
+            <item><description><see cref="F:log4net.Core.FixFlags.ThreadName"/></description></item>\r
+            <item><description><see cref="F:log4net.Core.FixFlags.Exception"/></description></item>\r
+            <item><description><see cref="F:log4net.Core.FixFlags.Domain"/></description></item>\r
+            <item><description><see cref="F:log4net.Core.FixFlags.Properties"/></description></item>\r
+            </list>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LoggingEvent">\r
+            <summary>\r
+            The internal representation of logging events. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            When an affirmative decision is made to log then a \r
+            <see cref="T:log4net.Core.LoggingEvent"/> instance is created. This instance \r
+            is passed around to the different log4net components.\r
+            </para>\r
+            <para>\r
+            This class is of concern to those wishing to extend log4net.\r
+            </para>\r
+            <para>\r
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>\r
+            are considered volatile, that is the values are correct at the\r
+            time the event is delivered to appenders, but will not be consistent\r
+            at any time afterwards. If an event is to be stored and then processed\r
+            at a later time these volatile values must be fixed by calling\r
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty\r
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it\r
+            is essential to maintaining data consistency.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Daniel Cazzulino</author>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.HostNameProperty">\r
+            <summary>\r
+            The key into the Properties map for the host name value.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.IdentityProperty">\r
+            <summary>\r
+            The key into the Properties map for the thread identity value.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.UserNameProperty">\r
+            <summary>\r
+            The key into the Properties map for the user name value.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,System.String,log4net.Core.Level,System.Object,System.Exception)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class\r
+            from the supplied parameters.\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <param name="repository">The repository this event is logged in.</param>\r
+            <param name="loggerName">The name of the logger of this event.</param>\r
+            <param name="level">The level of this event.</param>\r
+            <param name="message">The message of this event.</param>\r
+            <param name="exception">The exception for this event.</param>\r
+            <remarks>\r
+            <para>\r
+            Except <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>, <see cref="P:log4net.Core.LoggingEvent.Level"/> and <see cref="P:log4net.Core.LoggingEvent.LoggerName"/>, \r
+            all fields of <c>LoggingEvent</c> are filled when actually needed. Call\r
+            <see cref="M:FixVolatileData()"/> to cache all data locally\r
+            to prevent inconsistencies.\r
+            </para>\r
+            <para>This method is called by the log4net framework\r
+            to create a logging event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData,log4net.Core.FixFlags)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class \r
+            using specific data.\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <param name="repository">The repository this event is logged in.</param>\r
+            <param name="data">Data used to initialize the logging event.</param>\r
+            <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>\r
+            <remarks>\r
+            <para>\r
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>\r
+            to be created independently of the log4net framework. This can\r
+            be useful if you require a custom serialization scheme.\r
+            </para>\r
+            <para>\r
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an \r
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.\r
+            </para>\r
+            <para>\r
+            The <paramref name="fixedData"/> parameter should be used to specify which fields in the\r
+            <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>\r
+            will be captured from the environment if requested or fixed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Type,log4net.Repository.ILoggerRepository,log4net.Core.LoggingEventData)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class \r
+            using specific data.\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <param name="repository">The repository this event is logged in.</param>\r
+            <param name="data">Data used to initialize the logging event.</param>\r
+            <remarks>\r
+            <para>\r
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>\r
+            to be created independently of the log4net framework. This can\r
+            be useful if you require a custom serialization scheme.\r
+            </para>\r
+            <para>\r
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an \r
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.\r
+            </para>\r
+            <para>\r
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,\r
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>\r
+            parameter and no other data should be captured from the environment.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.#ctor(log4net.Core.LoggingEventData)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class \r
+            using specific data.\r
+            </summary>\r
+            <param name="data">Data used to initialize the logging event.</param>\r
+            <remarks>\r
+            <para>\r
+            This constructor is provided to allow a <see cref="T:log4net.Core.LoggingEvent"/>\r
+            to be created independently of the log4net framework. This can\r
+            be useful if you require a custom serialization scheme.\r
+            </para>\r
+            <para>\r
+            Use the <see cref="M:GetLoggingEventData(FixFlags)"/> method to obtain an \r
+            instance of the <see cref="T:log4net.Core.LoggingEventData"/> class.\r
+            </para>\r
+            <para>\r
+            This constructor sets this objects <see cref="P:log4net.Core.LoggingEvent.Fix"/> flags to <see cref="F:log4net.Core.FixFlags.All"/>,\r
+            this assumes that all the data relating to this event is passed in via the <paramref name="data"/>\r
+            parameter and no other data should be captured from the environment.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization constructor\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>\r
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.LoggingEvent"/> class \r
+            with serialized data.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.EnsureRepository(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Ensure that the repository is set.\r
+            </summary>\r
+            <param name="repository">the value for the repository</param>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)">\r
+            <summary>\r
+            Write the rendered message to a TextWriter\r
+            </summary>\r
+            <param name="writer">the writer to write the message to</param>\r
+            <remarks>\r
+            <para>\r
+            Unlike the <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property this method\r
+            does store the message data in the internal cache. Therefore \r
+            if called only once this method should be faster than the\r
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property, however if the message is\r
+            to be accessed multiple times then the property will be more efficient.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>\r
+            <param name="context">The destination for this serialization.</param>\r
+            <remarks>\r
+            <para>\r
+            The data in this event must be fixed before it can be serialized.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:FixVolatileData()"/> method must be called during the\r
+            <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method call if this event \r
+            is to be used outside that method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData">\r
+            <summary>\r
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </summary>\r
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>\r
+            <remarks>\r
+            <para>\r
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a\r
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.\r
+            </para>\r
+            <para>\r
+            Does a <see cref="F:log4net.Core.FixFlags.Partial"/> fix of the data\r
+            in the logging event before returning the event data.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.GetLoggingEventData(log4net.Core.FixFlags)">\r
+            <summary>\r
+            Gets the portable data for this <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </summary>\r
+            <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>\r
+            <returns>The <see cref="T:log4net.Core.LoggingEventData"/> for this event.</returns>\r
+            <remarks>\r
+            <para>\r
+            A new <see cref="T:log4net.Core.LoggingEvent"/> can be constructed using a\r
+            <see cref="T:log4net.Core.LoggingEventData"/> instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionStrRep">\r
+            <summary>\r
+            Returns this event's exception's rendered using the \r
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </summary>\r
+            <returns>\r
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            <b>Obsolete. Use <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> instead.</b>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.GetExceptionString">\r
+            <summary>\r
+            Returns this event's exception's rendered using the \r
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </summary>\r
+            <returns>\r
+            This event's exception's rendered using the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Returns this event's exception's rendered using the \r
+            <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData">\r
+            <summary>\r
+            Fix instance fields that hold volatile data.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>\r
+            are considered volatile, that is the values are correct at the\r
+            time the event is delivered to appenders, but will not be consistent\r
+            at any time afterwards. If an event is to be stored and then processed\r
+            at a later time these volatile values must be fixed by calling\r
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty\r
+            incurred by calling <see cref="M:FixVolatileData()"/> but it\r
+            is essential to maintaining data consistency.\r
+            </para>\r
+            <para>\r
+            Calling <see cref="M:FixVolatileData()"/> is equivalent to\r
+            calling <see cref="M:FixVolatileData(bool)"/> passing the parameter\r
+            <c>false</c>.\r
+            </para>\r
+            <para>\r
+            See <see cref="M:FixVolatileData(bool)"/> for more\r
+            information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(System.Boolean)">\r
+            <summary>\r
+            Fixes instance fields that hold volatile data.\r
+            </summary>\r
+            <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>\r
+            <remarks>\r
+            <para>\r
+            Some of the values in instances of <see cref="T:log4net.Core.LoggingEvent"/>\r
+            are considered volatile, that is the values are correct at the\r
+            time the event is delivered to appenders, but will not be consistent\r
+            at any time afterwards. If an event is to be stored and then processed\r
+            at a later time these volatile values must be fixed by calling\r
+            <see cref="M:FixVolatileData()"/>. There is a performance penalty\r
+            for incurred by calling <see cref="M:FixVolatileData()"/> but it\r
+            is essential to maintaining data consistency.\r
+            </para>\r
+            <para>\r
+            The <paramref name="fastButLoose"/> param controls the data that\r
+            is fixed. Some of the data that can be fixed takes a long time to \r
+            generate, therefore if you do not require those settings to be fixed\r
+            they can be ignored by setting the <paramref name="fastButLoose"/> param\r
+            to <c>true</c>. This setting will ignore the <see cref="P:log4net.Core.LoggingEvent.LocationInformation"/>\r
+            and <see cref="P:log4net.Core.LoggingEvent.UserName"/> settings.\r
+            </para>\r
+            <para>\r
+            Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all \r
+            settings are fixed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)">\r
+            <summary>\r
+            Fix the fields specified by the <see cref="T:log4net.Core.FixFlags"/> parameter\r
+            </summary>\r
+            <param name="flags">the fields to fix</param>\r
+            <remarks>\r
+            <para>\r
+            Only fields specified in the <paramref name="flags"/> will be fixed.\r
+            Fields will not be fixed if they have previously been fixed.\r
+            It is not possible to 'unfix' a field.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.LookupProperty(System.String)">\r
+            <summary>\r
+            Lookup a composite property in this event\r
+            </summary>\r
+            <param name="key">the key for the property to lookup</param>\r
+            <returns>the value for the property</returns>\r
+            <remarks>\r
+            <para>\r
+            This event has composite properties that combine together properties from\r
+            several different contexts in the following order:\r
+            <list type="definition">\r
+               <item>\r
+                       <term>this events properties</term>\r
+                       <description>\r
+                       This event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These \r
+                       properties are specific to this event only.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>the thread properties</term>\r
+                       <description>\r
+                       The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current\r
+                       thread. These properties are shared by all events logged on this thread.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>the global properties</term>\r
+                       <description>\r
+                       The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These \r
+                       properties are shared by all the threads in the AppDomain.\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LoggingEvent.GetProperties">\r
+            <summary>\r
+            Get all the composite properties in this event\r
+            </summary>\r
+            <returns>the <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the properties</returns>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/> for details of the composite properties \r
+            stored by the event.\r
+            </para>\r
+            <para>\r
+            This method returns a single <see cref="T:log4net.Util.PropertiesDictionary"/> containing all the\r
+            properties defined for this event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_data">\r
+            <summary>\r
+            The internal logging event data.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_compositeProperties">\r
+            <summary>\r
+            The internal logging event data.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_eventProperties">\r
+            <summary>\r
+            The internal logging event data.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_callerStackBoundaryDeclaringType">\r
+            <summary>\r
+            The fully qualified Type of the calling \r
+            logger class in the stack frame (i.e. the declaring type of the method).\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_message">\r
+            <summary>\r
+            The application supplied message of logging event.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_thrownException">\r
+            <summary>\r
+            The exception that was thrown.\r
+            </summary>\r
+            <remarks>\r
+            This is not serialized. The string representation\r
+            is serialized instead.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_repository">\r
+            <summary>\r
+            The repository that generated the logging event\r
+            </summary>\r
+            <remarks>\r
+            This is not serialized.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_fixFlags">\r
+            <summary>\r
+            The fix state for this event\r
+            </summary>\r
+            <remarks>\r
+            These flags indicate which fields have been fixed.\r
+            Not serialized.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Core.LoggingEvent.m_cacheUpdatable">\r
+            <summary>\r
+            Indicated that the internal cache is updateable (ie not fixed)\r
+            </summary>\r
+            <remarks>\r
+            This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler\r
+            changes in the caching strategy.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.StartTime">\r
+            <summary>\r
+            Gets the time when the current process started.\r
+            </summary>\r
+            <value>\r
+            This is the time when this process started.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The TimeStamp is stored in the local time zone for this computer.\r
+            </para>\r
+            <para>\r
+            Tries to get the start time for the current process.\r
+            Failing that it returns the time of the first call to\r
+            this property.\r
+            </para>\r
+            <para>\r
+            Note that AppDomains may be loaded and unloaded within the\r
+            same process without the process terminating and therefore\r
+            without the process start time being reset.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.Level">\r
+            <summary>\r
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="P:log4net.Core.LoggingEvent.Level"/> of the logging event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.TimeStamp">\r
+            <summary>\r
+            Gets the time of the logging event.\r
+            </summary>\r
+            <value>\r
+            The time of the logging event.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The TimeStamp is stored in the local time zone for this computer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.LoggerName">\r
+            <summary>\r
+            Gets the name of the logger that logged the event.\r
+            </summary>\r
+            <value>\r
+            The name of the logger that logged the event.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the name of the logger that logged the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.LocationInformation">\r
+            <summary>\r
+            Gets the location information for this logging event.\r
+            </summary>\r
+            <value>\r
+            The location information for this logging event.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The collected information is cached for future use.\r
+            </para>\r
+            <para>\r
+            See the <see cref="T:log4net.Core.LocationInfo"/> class for more information on\r
+            supported frameworks and the different behavior in Debug and\r
+            Release builds.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.MessageObject">\r
+            <summary>\r
+            Gets the message object used to initialize this event.\r
+            </summary>\r
+            <value>\r
+            The message object used to initialize this event.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the message object used to initialize this event.\r
+            Note that this event may not have a valid message object.\r
+            If the event is serialized the message object will not \r
+            be transferred. To get the text of the message the\r
+            <see cref="P:log4net.Core.LoggingEvent.RenderedMessage"/> property must be used \r
+            not this property.\r
+            </para>\r
+            <para>\r
+            If there is no defined message object for this event then\r
+            null will be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.ExceptionObject">\r
+            <summary>\r
+            Gets the exception object used to initialize this event.\r
+            </summary>\r
+            <value>\r
+            The exception object used to initialize this event.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the exception object used to initialize this event.\r
+            Note that this event may not have a valid exception object.\r
+            If the event is serialized the exception object will not \r
+            be transferred. To get the text of the exception the\r
+            <see cref="M:log4net.Core.LoggingEvent.GetExceptionString"/> method must be used \r
+            not this property.\r
+            </para>\r
+            <para>\r
+            If there is no defined exception object for this event then\r
+            null will be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.Repository">\r
+            <summary>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this event was created in.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.RenderedMessage">\r
+            <summary>\r
+            Gets the message, rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </summary>\r
+            <value>\r
+            The message rendered through the <see cref="P:log4net.Repository.ILoggerRepository.RendererMap"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The collected information is cached for future use.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.ThreadName">\r
+            <summary>\r
+            Gets the name of the current thread.  \r
+            </summary>\r
+            <value>\r
+            The name of the current thread, or the thread ID when \r
+            the name is not available.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The collected information is cached for future use.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.UserName">\r
+            <summary>\r
+            Gets the name of the current user.\r
+            </summary>\r
+            <value>\r
+            The name of the current user, or <c>NOT AVAILABLE</c> when the \r
+            underlying runtime has no support for retrieving the name of the \r
+            current user.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of\r
+            the current windows user.\r
+            </para>\r
+            <para>\r
+            To improve performance, we could cache the string representation of \r
+            the name, and reuse that as long as the identity stayed constant.  \r
+            Once the identity changed, we would need to re-assign and re-render \r
+            the string.\r
+            </para>\r
+            <para>\r
+            However, the <c>WindowsIdentity.GetCurrent()</c> call seems to \r
+            return different objects every time, so the current implementation \r
+            doesn't do this type of caching.\r
+            </para>\r
+            <para>\r
+            Timing for these operations:\r
+            </para>\r
+            <list type="table">\r
+              <listheader>\r
+                <term>Method</term>\r
+                <description>Results</description>\r
+              </listheader>\r
+              <item>\r
+                <term><c>WindowsIdentity.GetCurrent()</c></term>\r
+                <description>10000 loops, 00:00:00.2031250 seconds</description>\r
+              </item>\r
+              <item>\r
+                <term><c>WindowsIdentity.GetCurrent().Name</c></term>\r
+                <description>10000 loops, 00:00:08.0468750 seconds</description>\r
+              </item>\r
+            </list>\r
+            <para>\r
+            This means we could speed things up almost 40 times by caching the \r
+            value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since \r
+            this takes (8.04-0.20) = 7.84375 seconds.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.Identity">\r
+            <summary>\r
+            Gets the identity of the current thread principal.\r
+            </summary>\r
+            <value>\r
+            The string name of the identity of the current thread principal.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get\r
+            the name of the current thread principal.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.Domain">\r
+            <summary>\r
+            Gets the AppDomain friendly name.\r
+            </summary>\r
+            <value>\r
+            The AppDomain friendly name.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the AppDomain friendly name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.Properties">\r
+            <summary>\r
+            Additional event specific properties.\r
+            </summary>\r
+            <value>\r
+            Additional event specific properties.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            A logger or an appender may attach additional\r
+            properties to specific events. These properties\r
+            have a string key and an object value.\r
+            </para>\r
+            <para>\r
+            This property is for events that have been added directly to\r
+            this event. The aggregate properties (which include these\r
+            event properties) can be retrieved using <see cref="M:log4net.Core.LoggingEvent.LookupProperty(System.String)"/>\r
+            and <see cref="M:log4net.Core.LoggingEvent.GetProperties"/>.\r
+            </para>\r
+            <para>\r
+            Once the properties have been fixed <see cref="P:log4net.Core.LoggingEvent.Fix"/> this property\r
+            returns the combined cached properties. This ensures that updates to\r
+            this property are always reflected in the underlying storage. When\r
+            returning the combined properties there may be more keys in the\r
+            Dictionary than expected.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LoggingEvent.Fix">\r
+            <summary>\r
+            The fixed fields in this event\r
+            </summary>\r
+            <value>\r
+            The set of fields that are fixed in this event\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Fields will not be fixed if they have previously been fixed.\r
+            It is not possible to 'unfix' a field.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.LogImpl">\r
+            <summary>\r
+            Implementation of <see cref="T:log4net.ILog"/> wrapper interface.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This implementation of the <see cref="T:log4net.ILog"/> interface\r
+            forwards to the <see cref="T:log4net.Core.ILogger"/> held by the base class.\r
+            </para>\r
+            <para>\r
+            This logger has methods to allow the caller to log at the following\r
+            levels:\r
+            </para>\r
+            <list type="definition">\r
+              <item>\r
+                <term>DEBUG</term>\r
+                <description>\r
+                The <see cref="M:Debug(object)"/> and <see cref="M:DebugFormat(string, object[])"/> methods log messages\r
+                at the <c>DEBUG</c> level. That is the level with that name defined in the\r
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value\r
+                for this level is <see cref="F:log4net.Core.Level.Debug"/>. The <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>\r
+                property tests if this level is enabled for logging.\r
+                </description>\r
+              </item>\r
+              <item>\r
+                <term>INFO</term>\r
+                <description>\r
+                The <see cref="M:Info(object)"/> and <see cref="M:InfoFormat(string, object[])"/> methods log messages\r
+                at the <c>INFO</c> level. That is the level with that name defined in the\r
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value\r
+                for this level is <see cref="F:log4net.Core.Level.Info"/>. The <see cref="P:log4net.Core.LogImpl.IsInfoEnabled"/>\r
+                property tests if this level is enabled for logging.\r
+                </description>\r
+              </item>\r
+              <item>\r
+                <term>WARN</term>\r
+                <description>\r
+                The <see cref="M:Warn(object)"/> and <see cref="M:WarnFormat(string, object[])"/> methods log messages\r
+                at the <c>WARN</c> level. That is the level with that name defined in the\r
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value\r
+                for this level is <see cref="F:log4net.Core.Level.Warn"/>. The <see cref="P:log4net.Core.LogImpl.IsWarnEnabled"/>\r
+                property tests if this level is enabled for logging.\r
+                </description>\r
+              </item>\r
+              <item>\r
+                <term>ERROR</term>\r
+                <description>\r
+                The <see cref="M:Error(object)"/> and <see cref="M:ErrorFormat(string, object[])"/> methods log messages\r
+                at the <c>ERROR</c> level. That is the level with that name defined in the\r
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value\r
+                for this level is <see cref="F:log4net.Core.Level.Error"/>. The <see cref="P:log4net.Core.LogImpl.IsErrorEnabled"/>\r
+                property tests if this level is enabled for logging.\r
+                </description>\r
+              </item>\r
+              <item>\r
+                <term>FATAL</term>\r
+                <description>\r
+                The <see cref="M:Fatal(object)"/> and <see cref="M:FatalFormat(string, object[])"/> methods log messages\r
+                at the <c>FATAL</c> level. That is the level with that name defined in the\r
+                repositories <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/>. The default value\r
+                for this level is <see cref="F:log4net.Core.Level.Fatal"/>. The <see cref="P:log4net.Core.LogImpl.IsFatalEnabled"/>\r
+                property tests if this level is enabled for logging.\r
+                </description>\r
+              </item>\r
+            </list>\r
+            <para>\r
+            The values for these levels and their semantic meanings can be changed by \r
+            configuring the <see cref="P:log4net.Repository.ILoggerRepository.LevelMap"/> for the repository.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.ILog">\r
+            <summary>\r
+            The ILog interface is use by application to log messages into\r
+            the log4net framework.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Use the <see cref="T:log4net.LogManager"/> to obtain logger instances\r
+            that implement this interface. The <see cref="M:LogManager.GetLogger(Assembly,Type)"/>\r
+            static method is used to get logger instances.\r
+            </para>\r
+            <para>\r
+            This class contains methods for logging at different levels and also\r
+            has properties for determining if those logging levels are\r
+            enabled in the current configuration.\r
+            </para>\r
+            <para>\r
+            This interface can be implemented in different ways. This documentation\r
+            specifies reasonable behavior that a caller can expect from the actual\r
+            implementation, however different implementations reserve the right to\r
+            do things differently.\r
+            </para>\r
+            </remarks>\r
+            <example>Simple example of logging messages\r
+            <code lang="C#">\r
+            ILog log = LogManager.GetLogger("application-log");\r
+            \r
+            log.Info("Application Start");\r
+            log.Debug("This is a debug message");\r
+            \r
+            if (log.IsDebugEnabled)\r
+            {\r
+               log.Debug("This is another debug message");\r
+            }\r
+            </code>\r
+            </example>\r
+            <seealso cref="T:log4net.LogManager"/>\r
+            <seealso cref="M:LogManager.GetLogger(Assembly, Type)"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.ILog.Debug(System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>DEBUG</c>\r
+            enabled by comparing the level of this logger with the \r
+            <see cref="F:log4net.Core.Level.Debug"/> level. If this logger is\r
+            <c>DEBUG</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Debug(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Debug(System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:Debug(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object[])">\r
+            <overloads>Log a formatted string with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads>\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.DebugFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.DebugFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Info(System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>\r
+            <summary>\r
+            Logs a message object with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>INFO</c>\r
+            enabled by comparing the level of this logger with the \r
+            <see cref="F:log4net.Core.Level.Info"/> level. If this logger is\r
+            <c>INFO</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Info(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <param name="message">The message object to log.</param>\r
+            <seealso cref="M:Info(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Info(System.Object,System.Exception)">\r
+            <summary>\r
+            Logs a message object with the <c>INFO</c> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:Info(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object[])">\r
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads>\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.InfoFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.InfoFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Warn(System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>WARN</c>\r
+            enabled by comparing the level of this logger with the \r
+            <see cref="F:log4net.Core.Level.Warn"/> level. If this logger is\r
+            <c>WARN</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Warn(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <param name="message">The message object to log.</param>\r
+            <seealso cref="M:Warn(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Warn(System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:Warn(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object[])">\r
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads>\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.WarnFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.WarnFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Error(System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>\r
+            <summary>\r
+            Logs a message object with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>ERROR</c>\r
+            enabled by comparing the level of this logger with the \r
+            <see cref="F:log4net.Core.Level.Error"/> level. If this logger is\r
+            <c>ERROR</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Error(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Error(System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:Error(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object[])">\r
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads>\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.ErrorFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Fatal(System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>FATAL</c>\r
+            enabled by comparing the level of this logger with the \r
+            <see cref="F:log4net.Core.Level.Fatal"/> level. If this logger is\r
+            <c>FATAL</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Fatal(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <param name="message">The message object to log.</param>\r
+            <seealso cref="M:Fatal(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.Fatal(System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object[])">\r
+            <overloads>Log a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads>\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.FatalFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object,Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.ILog.FatalFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:String.Format(string, object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object,Exception)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.ILog.IsDebugEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Debug"/> events, <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This function is intended to lessen the computational cost of\r
+            disabled log debug statements.\r
+            </para>\r
+            <para> For some ILog interface <c>log</c>, when you write:</para>\r
+            <code lang="C#">\r
+            log.Debug("This is entry number: " + i );\r
+            </code>\r
+            <para>\r
+            You incur the cost constructing the message, string construction and concatenation in\r
+            this case, regardless of whether the message is logged or not.\r
+            </para>\r
+            <para>\r
+            If you are worried about speed (who isn't), then you should write:\r
+            </para>\r
+            <code lang="C#">\r
+            if (log.IsDebugEnabled)\r
+            { \r
+                log.Debug("This is entry number: " + i );\r
+            }\r
+            </code>\r
+            <para>\r
+            This way you will not incur the cost of parameter\r
+            construction if debugging is disabled for <c>log</c>. On\r
+            the other hand, if the <c>log</c> is debug enabled, you\r
+            will incur the cost of evaluating whether the logger is debug\r
+            enabled twice. Once in <see cref="P:log4net.ILog.IsDebugEnabled"/> and once in\r
+            the <see cref="M:Debug(object)"/>.  This is an insignificant overhead\r
+            since evaluating a logger takes about 1% of the time it\r
+            takes to actually log. This is the preferred style of logging.\r
+            </para>\r
+            <para>Alternatively if your logger is available statically then the is debug\r
+            enabled state can be stored in a static variable like this:\r
+            </para>\r
+            <code lang="C#">\r
+            private static readonly bool isDebugEnabled = log.IsDebugEnabled;\r
+            </code>\r
+            <para>\r
+            Then when you come to log you can write:\r
+            </para>\r
+            <code lang="C#">\r
+            if (isDebugEnabled)\r
+            { \r
+                log.Debug("This is entry number: " + i );\r
+            }\r
+            </code>\r
+            <para>\r
+            This way the debug enabled state is only queried once\r
+            when the class is loaded. Using a <c>private static readonly</c>\r
+            variable is the most efficient because it is a run time constant\r
+            and can be heavily optimized by the JIT compiler.\r
+            </para>\r
+            <para>\r
+            Of course if you use a static readonly variable to\r
+            hold the enabled state of the logger then you cannot\r
+            change the enabled state at runtime to vary the logging\r
+            that is produced. You have to decide if you need absolute\r
+            speed or runtime flexibility.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+            <seealso cref="M:DebugFormat(IFormatProvider, string, object[])"/>\r
+        </member>\r
+        <member name="P:log4net.ILog.IsInfoEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Info"/> events, <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.\r
+            </remarks>\r
+            <seealso cref="M:Info(object)"/>\r
+            <seealso cref="M:InfoFormat(IFormatProvider, string, object[])"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.ILog.IsWarnEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Warn"/> events, <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.\r
+            </remarks>\r
+            <seealso cref="M:Warn(object)"/>\r
+            <seealso cref="M:WarnFormat(IFormatProvider, string, object[])"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.ILog.IsErrorEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Error"/> events, <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.\r
+            </remarks>\r
+            <seealso cref="M:Error(object)"/>\r
+            <seealso cref="M:ErrorFormat(IFormatProvider, string, object[])"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.ILog.IsFatalEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <see cref="F:log4net.Core.Level.Fatal"/> events, <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            For more information see <see cref="P:log4net.ILog.IsDebugEnabled"/>.\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object)"/>\r
+            <seealso cref="M:FatalFormat(IFormatProvider, string, object[])"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.#ctor(log4net.Core.ILogger)">\r
+            <summary>\r
+            Construct a new wrapper for the specified logger.\r
+            </summary>\r
+            <param name="logger">The logger to wrap.</param>\r
+            <remarks>\r
+            <para>\r
+            Construct a new wrapper for the specified logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.ReloadLevels(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Virtual method called when the configuration of the repository changes\r
+            </summary>\r
+            <param name="repository">the repository holding the levels</param>\r
+            <remarks>\r
+            <para>\r
+            Virtual method called when the configuration of the repository changes\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object)">\r
+            <summary>\r
+            Logs a message object with the <c>DEBUG</c> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>DEBUG</c>\r
+            enabled by comparing the level of this logger with the \r
+            <c>DEBUG</c> level. If this logger is\r
+            <c>DEBUG</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para>\r
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Debug(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Debug(System.Object,System.Exception)">\r
+            <summary>\r
+            Logs a message object with the <c>DEBUG</c> level\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs a message object with the <c>DEBUG</c> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> passed\r
+            as a parameter.\r
+            </para>\r
+            <para>\r
+            See the <see cref="M:Debug(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Debug(object)"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>DEBUG</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>DEBUG</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>DEBUG</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>DEBUG</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:DebugFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.DebugFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>DEBUG</c> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Debug(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Info(System.Object)">\r
+            <summary>\r
+            Logs a message object with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>INFO</c>\r
+            enabled by comparing the level of this logger with the \r
+            <c>INFO</c> level. If this logger is\r
+            <c>INFO</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para>\r
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:Info(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Info(System.Object,System.Exception)">\r
+            <summary>\r
+            Logs a message object with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs a message object with the <c>INFO</c> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> \r
+            passed as a parameter.\r
+            </para>\r
+            <para>\r
+            See the <see cref="M:Info(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Info(object)"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:InfoFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.InfoFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>INFO</c> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Info(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object)">\r
+            <summary>\r
+            Logs a message object with the <c>WARN</c> level.\r
+            </summary>\r
+            <param name="message">the message object to log</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>WARN</c>\r
+            enabled by comparing the level of this logger with the \r
+            <c>WARN</c> level. If this logger is\r
+            <c>WARN</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger and \r
+            also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para>\r
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this\r
+            method will print the name of the <see cref="T:System.Exception"/> but no\r
+            stack trace. To print a stack trace use the \r
+            <see cref="M:Warn(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Warn(System.Object,System.Exception)">\r
+            <summary>\r
+            Logs a message object with the <c>WARN</c> level\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs a message object with the <c>WARN</c> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> \r
+            passed as a parameter.\r
+            </para>\r
+            <para>\r
+            See the <see cref="M:Warn(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Warn(object)"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>WARN</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>WARN</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>WARN</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>WARN</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:WarnFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.WarnFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>WARN</c> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Warn(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Error(System.Object)">\r
+            <summary>\r
+            Logs a message object with the <c>ERROR</c> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>ERROR</c>\r
+            enabled by comparing the level of this logger with the \r
+            <c>ERROR</c> level. If this logger is\r
+            <c>ERROR</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger and \r
+            also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para>\r
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this\r
+            method will print the name of the <see cref="T:System.Exception"/> but no\r
+            stack trace. To print a stack trace use the \r
+            <see cref="M:Error(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Error(System.Object,System.Exception)">\r
+            <summary>\r
+            Logs a message object with the <c>ERROR</c> level\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs a message object with the <c>ERROR</c> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> \r
+            passed as a parameter.\r
+            </para>\r
+            <para>\r
+            See the <see cref="M:Error(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Error(object)"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>ERROR</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>ERROR</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>ERROR</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>ERROR</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:ErrorFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.ErrorFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>ERROR</c> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Error(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object)">\r
+            <summary>\r
+            Logs a message object with the <c>FATAL</c> level.\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>FATAL</c>\r
+            enabled by comparing the level of this logger with the \r
+            <c>FATAL</c> level. If this logger is\r
+            <c>FATAL</c> enabled, then it converts the message object\r
+            (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger and \r
+            also higher in the hierarchy depending on the value of the \r
+            additivity flag.\r
+            </para>\r
+            <para>\r
+            <b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> to this\r
+            method will print the name of the <see cref="T:System.Exception"/> but no\r
+            stack trace. To print a stack trace use the \r
+            <see cref="M:Fatal(object,Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.Fatal(System.Object,System.Exception)">\r
+            <summary>\r
+            Logs a message object with the <c>FATAL</c> level\r
+            </summary>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs a message object with the <c>FATAL</c> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> <paramref name="exception"/> \r
+            passed as a parameter.\r
+            </para>\r
+            <para>\r
+            See the <see cref="M:Fatal(object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:Fatal(object)"/>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>FATAL</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>FATAL</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>FATAL</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <c>FATAL</c> level.\r
+            </summary>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            The string is formatted using the <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>\r
+            format provider. To specify a localized provider use the\r
+            <see cref="M:FatalFormat(IFormatProvider,string,object[])"/> method.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.FatalFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <c>FATAL</c> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <see cref="M:String.Format(IFormatProvider, string, object[])"/> method. See\r
+            <c>String.Format</c> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:Fatal(object)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.LogImpl.LoggerRepositoryConfigurationChanged(System.Object,System.EventArgs)">\r
+            <summary>\r
+            Event handler for the <see cref="E:log4net.Repository.ILoggerRepository.ConfigurationChanged"/> event\r
+            </summary>\r
+            <param name="sender">the repository</param>\r
+            <param name="e">Empty</param>\r
+        </member>\r
+        <member name="F:log4net.Core.LogImpl.ThisDeclaringType">\r
+            <summary>\r
+            The fully qualified name of this declaring type not the type of any subclass.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.LogImpl.IsDebugEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <c>DEBUG</c>\r
+            level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <c>DEBUG</c> events,\r
+            <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This function is intended to lessen the computational cost of\r
+            disabled log debug statements.\r
+            </para>\r
+            <para>\r
+            For some <c>log</c> Logger object, when you write:\r
+            </para>\r
+            <code lang="C#">\r
+            log.Debug("This is entry number: " + i );\r
+            </code>\r
+            <para>\r
+            You incur the cost constructing the message, concatenation in\r
+            this case, regardless of whether the message is logged or not.\r
+            </para>\r
+            <para>\r
+            If you are worried about speed, then you should write:\r
+            </para>\r
+            <code lang="C#">\r
+            if (log.IsDebugEnabled())\r
+            { \r
+             log.Debug("This is entry number: " + i );\r
+            }\r
+            </code>\r
+            <para>\r
+            This way you will not incur the cost of parameter\r
+            construction if debugging is disabled for <c>log</c>. On\r
+            the other hand, if the <c>log</c> is debug enabled, you\r
+            will incur the cost of evaluating whether the logger is debug\r
+            enabled twice. Once in <c>IsDebugEnabled</c> and once in\r
+            the <c>Debug</c>.  This is an insignificant overhead\r
+            since evaluating a logger takes about 1% of the time it\r
+            takes to actually log.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.LogImpl.IsInfoEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <c>INFO</c> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <c>INFO</c> events,\r
+            <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples \r
+            of using this method.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:log4net.Core.LogImpl.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.Core.LogImpl.IsWarnEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <c>WARN</c> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <c>WARN</c> events,\r
+            <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples \r
+            of using this method.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.Core.LogImpl.IsErrorEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <c>ERROR</c> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <c>ERROR</c> events,\r
+            <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="P:log4net.Core.LogImpl.IsFatalEnabled">\r
+            <summary>\r
+            Checks if this logger is enabled for the <c>FATAL</c> level.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this logger is enabled for <c>FATAL</c> events,\r
+            <c>false</c> otherwise.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Core.LogImpl.IsDebugEnabled"/> for more information and examples of using this method.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="T:log4net.Core.MethodItem">\r
+            <summary>\r
+            provides method information without actually referencing a System.Reflection.MethodBase\r
+            as that would require that the containing assembly is loaded.\r
+            </summary>\r
+            \r
+        </member>\r
+        <member name="F:log4net.Core.MethodItem.NA">\r
+            <summary>\r
+            When location information is not available the constant\r
+            <c>NA</c> is returned. Current value of this string\r
+            constant is <b>?</b>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.MethodItem.#ctor">\r
+            <summary>\r
+            constructs a method item for an unknown method.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String)">\r
+            <summary>\r
+            constructs a method item from the name of the method.\r
+            </summary>\r
+            <param name="name"></param>\r
+        </member>\r
+        <member name="M:log4net.Core.MethodItem.#ctor(System.String,System.String[])">\r
+            <summary>\r
+            constructs a method item from the name of the method and its parameters.\r
+            </summary>\r
+            <param name="name"></param>\r
+            <param name="parameters"></param>\r
+        </member>\r
+        <member name="M:log4net.Core.MethodItem.#ctor(System.Reflection.MethodBase)">\r
+            <summary>\r
+            constructs a method item from a method base by determining the method name and its parameters.\r
+            </summary>\r
+            <param name="methodBase"></param>\r
+        </member>\r
+        <member name="F:log4net.Core.MethodItem.declaringType">\r
+            <summary>\r
+            The fully qualified type of the StackFrameItem class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.MethodItem.Name">\r
+            <summary>\r
+            Gets the method name of the caller making the logging \r
+            request.\r
+            </summary>\r
+            <value>\r
+            The method name of the caller making the logging \r
+            request.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the method name of the caller making the logging \r
+            request.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.MethodItem.Parameters">\r
+            <summary>\r
+            Gets the method parameters of the caller making\r
+            the logging request.\r
+            </summary>\r
+            <value>\r
+            The method parameters of the caller making\r
+            the logging request\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the method parameters of the caller making\r
+            the logging request.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.SecurityContext">\r
+            <summary>\r
+            A SecurityContext used by log4net when interacting with protected resources\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A SecurityContext used by log4net when interacting with protected resources\r
+            for example with operating system services. This can be used to impersonate\r
+            a principal that has been granted privileges on the system resources.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Core.SecurityContext.Impersonate(System.Object)">\r
+            <summary>\r
+            Impersonate this SecurityContext\r
+            </summary>\r
+            <param name="state">State supplied by the caller</param>\r
+            <returns>An <see cref="T:System.IDisposable"/> instance that will\r
+            revoke the impersonation of this SecurityContext, or <c>null</c></returns>\r
+            <remarks>\r
+            <para>\r
+            Impersonate this security context. Further calls on the current\r
+            thread should now be made in the security context provided\r
+            by this object. When the <see cref="T:System.IDisposable"/> result \r
+            <see cref="M:System.IDisposable.Dispose"/> method is called the security\r
+            context of the thread should be reverted to the state it was in\r
+            before <see cref="M:log4net.Core.SecurityContext.Impersonate(System.Object)"/> was called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.SecurityContextProvider">\r
+            <summary>\r
+            The <see cref="T:log4net.Core.SecurityContextProvider"/> providers default <see cref="T:log4net.Core.SecurityContext"/> instances.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A configured component that interacts with potentially protected system\r
+            resources uses a <see cref="T:log4net.Core.SecurityContext"/> to provide the elevated\r
+            privileges required. If the <see cref="T:log4net.Core.SecurityContext"/> object has\r
+            been not been explicitly provided to the component then the component\r
+            will request one from this <see cref="T:log4net.Core.SecurityContextProvider"/>.\r
+            </para>\r
+            <para>\r
+            By default the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is\r
+            an instance of <see cref="T:log4net.Core.SecurityContextProvider"/> which returns only\r
+            <see cref="T:log4net.Util.NullSecurityContext"/> objects. This is a reasonable default\r
+            where the privileges required are not know by the system.\r
+            </para>\r
+            <para>\r
+            This default behavior can be overridden by subclassing the <see cref="T:log4net.Core.SecurityContextProvider"/>\r
+            and overriding the <see cref="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)"/> method to return\r
+            the desired <see cref="T:log4net.Core.SecurityContext"/> objects. The default provider\r
+            can be replaced by programmatically setting the value of the \r
+            <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> property.\r
+            </para>\r
+            <para>\r
+            An alternative is to use the <c>log4net.Config.SecurityContextProviderAttribute</c>\r
+            This attribute can be applied to an assembly in the same way as the\r
+            <c>log4net.Config.XmlConfiguratorAttribute"</c>. The attribute takes\r
+            the type to use as the <see cref="T:log4net.Core.SecurityContextProvider"/> as an argument.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Core.SecurityContextProvider.s_defaultProvider">\r
+            <summary>\r
+            The default provider\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.SecurityContextProvider.#ctor">\r
+            <summary>\r
+            Protected default constructor to allow subclassing\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Protected default constructor to allow subclassing\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.SecurityContextProvider.CreateSecurityContext(System.Object)">\r
+            <summary>\r
+            Create a SecurityContext for a consumer\r
+            </summary>\r
+            <param name="consumer">The consumer requesting the SecurityContext</param>\r
+            <returns>An impersonation context</returns>\r
+            <remarks>\r
+            <para>\r
+            The default implementation is to return a <see cref="T:log4net.Util.NullSecurityContext"/>.\r
+            </para>\r
+            <para>\r
+            Subclasses should override this method to provide their own\r
+            behavior.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.SecurityContextProvider.DefaultProvider">\r
+            <summary>\r
+            Gets or sets the default SecurityContextProvider\r
+            </summary>\r
+            <value>\r
+            The default SecurityContextProvider\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The default provider is used by configured components that\r
+            require a <see cref="T:log4net.Core.SecurityContext"/> and have not had one\r
+            given to them.\r
+            </para>\r
+            <para>\r
+            By default this is an instance of <see cref="T:log4net.Core.SecurityContextProvider"/>\r
+            that returns <see cref="T:log4net.Util.NullSecurityContext"/> objects.\r
+            </para>\r
+            <para>\r
+            The default provider can be set programmatically by setting\r
+            the value of this property to a sub class of <see cref="T:log4net.Core.SecurityContextProvider"/>\r
+            that has the desired behavior.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.StackFrameItem">\r
+            <summary>\r
+            provides stack frame information without actually referencing a System.Diagnostics.StackFrame\r
+            as that would require that the containing assembly is loaded.\r
+            </summary>\r
+            \r
+        </member>\r
+        <member name="F:log4net.Core.StackFrameItem.NA">\r
+            <summary>\r
+            When location information is not available the constant\r
+            <c>NA</c> is returned. Current value of this string\r
+            constant is <b>?</b>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.StackFrameItem.#ctor(System.Diagnostics.StackFrame)">\r
+            <summary>\r
+            returns a stack frame item from a stack frame. This \r
+            </summary>\r
+            <param name="frame"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="F:log4net.Core.StackFrameItem.declaringType">\r
+            <summary>\r
+            The fully qualified type of the StackFrameItem class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.StackFrameItem.ClassName">\r
+            <summary>\r
+            Gets the fully qualified class name of the caller making the logging \r
+            request.\r
+            </summary>\r
+            <value>\r
+            The fully qualified class name of the caller making the logging \r
+            request.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the fully qualified class name of the caller making the logging \r
+            request.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.StackFrameItem.FileName">\r
+            <summary>\r
+            Gets the file name of the caller.\r
+            </summary>\r
+            <value>\r
+            The file name of the caller.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the file name of the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.StackFrameItem.LineNumber">\r
+            <summary>\r
+            Gets the line number of the caller.\r
+            </summary>\r
+            <value>\r
+            The line number of the caller.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the line number of the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.StackFrameItem.Method">\r
+            <summary>\r
+            Gets the method name of the caller.\r
+            </summary>\r
+            <value>\r
+            The method name of the caller.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the method name of the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.StackFrameItem.FullInfo">\r
+            <summary>\r
+            Gets all available caller information\r
+            </summary>\r
+            <value>\r
+            All available caller information, in the format\r
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets all available caller information, in the format\r
+            <c>fully.qualified.classname.of.caller.methodName(Filename:line)</c>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.TimeEvaluator">\r
+            <summary>\r
+            An evaluator that triggers after specified number of seconds.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the specified time period \r
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.\r
+            </para>\r
+            </remarks>\r
+            <author>Robert Sevcik</author>\r
+        </member>\r
+        <member name="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL">\r
+            <summary>\r
+            The default time threshold for triggering in seconds. Zero means it won't trigger at all.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.TimeEvaluator.m_interval">\r
+            <summary>\r
+            The time threshold for triggering in seconds. Zero means it won't trigger at all.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.TimeEvaluator.m_lasttime">\r
+            <summary>\r
+            The time of last check. This gets updated when the object is created and when the evaluator triggers.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Core.TimeEvaluator.#ctor">\r
+            <summary>\r
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Create a new evaluator using the <see cref="F:log4net.Core.TimeEvaluator.DEFAULT_INTERVAL"/> time threshold in seconds.\r
+            </para>\r
+            <para>\r
+            This evaluator will trigger if the specified time period \r
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.TimeEvaluator.#ctor(System.Int32)">\r
+            <summary>\r
+            Create a new evaluator using the specified time threshold in seconds.\r
+            </summary>\r
+            <param name="interval">\r
+            The time threshold in seconds to trigger after.\r
+            Zero means it won't trigger at all.\r
+            </param>\r
+            <remarks>\r
+            <para>\r
+            Create a new evaluator using the specified time threshold in seconds.\r
+            </para>\r
+            <para>\r
+            This evaluator will trigger if the specified time period \r
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.TimeEvaluator.IsTriggeringEvent(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Is this <paramref name="loggingEvent"/> the triggering event?\r
+            </summary>\r
+            <param name="loggingEvent">The event to check</param>\r
+            <returns>This method returns <c>true</c>, if the specified time period \r
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.. \r
+            Otherwise it returns <c>false</c></returns>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the specified time period \r
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Core.TimeEvaluator.Interval">\r
+            <summary>\r
+            The time threshold in seconds to trigger after\r
+            </summary>\r
+            <value>\r
+            The time threshold in seconds to trigger after.\r
+            Zero means it won't trigger at all.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This evaluator will trigger if the specified time period \r
+            <see cref="P:log4net.Core.TimeEvaluator.Interval"/> has passed since last check.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.WrapperCreationHandler">\r
+            <summary>\r
+            Delegate used to handle creation of new wrappers.\r
+            </summary>\r
+            <param name="logger">The logger to wrap in a wrapper.</param>\r
+            <remarks>\r
+            <para>\r
+            Delegate used to handle creation of new wrappers. This delegate\r
+            is called from the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>\r
+            method to construct the wrapper for the specified logger.\r
+            </para>\r
+            <para>\r
+            The delegate to use is supplied to the <see cref="T:log4net.Core.WrapperMap"/>\r
+            constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Core.WrapperMap">\r
+            <summary>\r
+            Maps between logger objects and wrapper objects.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class maintains a mapping between <see cref="T:log4net.Core.ILogger"/> objects and\r
+            <see cref="T:log4net.Core.ILoggerWrapper"/> objects. Use the <see cref="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)"/> method to \r
+            lookup the <see cref="T:log4net.Core.ILoggerWrapper"/> for the specified <see cref="T:log4net.Core.ILogger"/>.\r
+            </para>\r
+            <para>\r
+            New wrapper instances are created by the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/>\r
+            method. The default behavior is for this method to delegate construction\r
+            of the wrapper to the <see cref="T:log4net.Core.WrapperCreationHandler"/> delegate supplied\r
+            to the constructor. This allows specialization of the behavior without\r
+            requiring subclassing of this type.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Core.WrapperMap.#ctor(log4net.Core.WrapperCreationHandler)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/>\r
+            </summary>\r
+            <param name="createWrapperHandler">The handler to use to create the wrapper objects.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Core.WrapperMap"/> class with \r
+            the specified handler to create the wrapper objects.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.WrapperMap.GetWrapper(log4net.Core.ILogger)">\r
+            <summary>\r
+            Gets the wrapper object for the specified logger.\r
+            </summary>\r
+            <returns>The wrapper object for the specified logger</returns>\r
+            <remarks>\r
+            <para>\r
+            If the logger is null then the corresponding wrapper is null.\r
+            </para>\r
+            <para>\r
+            Looks up the wrapper it it has previously been requested and\r
+            returns it. If the wrapper has never been requested before then\r
+            the <see cref="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)"/> virtual method is\r
+            called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.WrapperMap.CreateNewWrapperObject(log4net.Core.ILogger)">\r
+            <summary>\r
+            Creates the wrapper object for the specified logger.\r
+            </summary>\r
+            <param name="logger">The logger to wrap in a wrapper.</param>\r
+            <returns>The wrapper object for the logger.</returns>\r
+            <remarks>\r
+            <para>\r
+            This implementation uses the <see cref="T:log4net.Core.WrapperCreationHandler"/>\r
+            passed to the constructor to create the wrapper. This method\r
+            can be overridden in a subclass.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.WrapperMap.RepositoryShutdown(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Called when a monitored repository shutdown event is received.\r
+            </summary>\r
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down</param>\r
+            <remarks>\r
+            <para>\r
+            This method is called when a <see cref="T:log4net.Repository.ILoggerRepository"/> that this\r
+            <see cref="T:log4net.Core.WrapperMap"/> is holding loggers for has signaled its shutdown\r
+            event <see cref="E:log4net.Repository.ILoggerRepository.ShutdownEvent"/>. The default\r
+            behavior of this method is to release the references to the loggers\r
+            and their wrappers generated for this repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Core.WrapperMap.ILoggerRepository_Shutdown(System.Object,System.EventArgs)">\r
+            <summary>\r
+            Event handler for repository shutdown event.\r
+            </summary>\r
+            <param name="sender">The sender of the event.</param>\r
+            <param name="e">The event args.</param>\r
+        </member>\r
+        <member name="F:log4net.Core.WrapperMap.m_repositories">\r
+            <summary>\r
+            Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.WrapperMap.m_createWrapperHandler">\r
+            <summary>\r
+            The handler to use to create the extension wrapper objects.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Core.WrapperMap.m_shutdownHandler">\r
+            <summary>\r
+            Internal reference to the delegate used to register for repository shutdown events.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Core.WrapperMap.Repositories">\r
+            <summary>\r
+            Gets the map of logger repositories.\r
+            </summary>\r
+            <value>\r
+            Map of logger repositories.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the hashtable that is keyed on <see cref="T:log4net.Repository.ILoggerRepository"/>. The\r
+            values are hashtables keyed on <see cref="T:log4net.Core.ILogger"/> with the\r
+            value being the corresponding <see cref="T:log4net.Core.ILoggerWrapper"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.DateFormatter.AbsoluteTimeDateFormatter">\r
+            <summary>\r
+            Formats a <see cref="T:System.DateTime"/> as <c>"HH:mm:ss,fff"</c>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Formats a <see cref="T:System.DateTime"/> in the format <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.DateFormatter.IDateFormatter">\r
+            <summary>\r
+            Render a <see cref="T:System.DateTime"/> as a string.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface to abstract the rendering of a <see cref="T:System.DateTime"/>\r
+            instance into a string.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/> method is used to render the\r
+            date to a text writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.IDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">\r
+            <summary>\r
+            Formats the specified date as a string.\r
+            </summary>\r
+            <param name="dateToFormat">The date to format.</param>\r
+            <param name="writer">The writer to write to.</param>\r
+            <remarks>\r
+            <para>\r
+            Format the <see cref="T:System.DateTime"/> as a string and write it\r
+            to the <see cref="T:System.IO.TextWriter"/> provided.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.AbsoluteTimeDateFormat">\r
+            <summary>\r
+            String constant used to specify AbsoluteTimeDateFormat in layouts. Current value is <b>ABSOLUTE</b>.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.DateAndTimeDateFormat">\r
+            <summary>\r
+            String constant used to specify DateTimeDateFormat in layouts.  Current value is <b>DATE</b>.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.Iso8601TimeDateFormat">\r
+            <summary>\r
+            String constant used to specify ISO8601DateFormat in layouts. Current value is <b>ISO8601</b>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">\r
+            <summary>\r
+            Renders the date into a string. Format is <c>"HH:mm:ss"</c>.\r
+            </summary>\r
+            <param name="dateToFormat">The date to render into a string.</param>\r
+            <param name="buffer">The string builder to write to.</param>\r
+            <remarks>\r
+            <para>\r
+            Subclasses should override this method to render the date\r
+            into a string using a precision up to the second. This method\r
+            will be called at most once per second and the result will be\r
+            reused if it is needed again during the same second.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">\r
+            <summary>\r
+            Renders the date into a string. Format is "HH:mm:ss,fff".\r
+            </summary>\r
+            <param name="dateToFormat">The date to render into a string.</param>\r
+            <param name="writer">The writer to write to.</param>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> method to generate the\r
+            time string up to the seconds and then appends the current\r
+            milliseconds. The results from <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> are\r
+            cached and <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/> is called at most once\r
+            per second.\r
+            </para>\r
+            <para>\r
+            Sub classes should override <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)"/>\r
+            rather than <see cref="M:log4net.DateFormatter.AbsoluteTimeDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeToTheSecond">\r
+            <summary>\r
+            Last stored time with precision up to the second.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeBuf">\r
+            <summary>\r
+            Last stored time with precision up to the second, formatted\r
+            as a string.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.AbsoluteTimeDateFormatter.s_lastTimeStrings">\r
+            <summary>\r
+            Last stored time with precision up to the second, formatted\r
+            as a string.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.DateFormatter.DateTimeDateFormatter">\r
+            <summary>\r
+            Formats a <see cref="T:System.DateTime"/> as <c>"dd MMM yyyy HH:mm:ss,fff"</c>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Formats a <see cref="T:System.DateTime"/> in the format \r
+            <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, \r
+            <c>"06 Nov 1994 15:49:37,459"</c>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Angelika Schnagl</author>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.#ctor">\r
+            <summary>\r
+            Default constructor.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.DateTimeDateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">\r
+            <summary>\r
+            Formats the date without the milliseconds part\r
+            </summary>\r
+            <param name="dateToFormat">The date to format.</param>\r
+            <param name="buffer">The string builder to write to.</param>\r
+            <remarks>\r
+            <para>\r
+            Formats a DateTime in the format <c>"dd MMM yyyy HH:mm:ss"</c>\r
+            for example, <c>"06 Nov 1994 15:49:37"</c>.\r
+            </para>\r
+            <para>\r
+            The base class will append the <c>",fff"</c> milliseconds section.\r
+            This method will only be called at most once per second.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.DateTimeDateFormatter.m_dateTimeFormatInfo">\r
+            <summary>\r
+            The format info for the invariant culture.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.DateFormatter.Iso8601DateFormatter">\r
+            <summary>\r
+            Formats the <see cref="T:System.DateTime"/> as <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Formats the <see cref="T:System.DateTime"/> specified as a string: <c>"yyyy-MM-dd HH:mm:ss,fff"</c>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.Iso8601DateFormatter.FormatDateWithoutMillis(System.DateTime,System.Text.StringBuilder)">\r
+            <summary>\r
+            Formats the date without the milliseconds part\r
+            </summary>\r
+            <param name="dateToFormat">The date to format.</param>\r
+            <param name="buffer">The string builder to write to.</param>\r
+            <remarks>\r
+            <para>\r
+            Formats the date specified as a string: <c>"yyyy-MM-dd HH:mm:ss"</c>.\r
+            </para>\r
+            <para>\r
+            The base class will append the <c>",fff"</c> milliseconds section.\r
+            This method will only be called at most once per second.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.DateFormatter.SimpleDateFormatter">\r
+            <summary>\r
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Formats the <see cref="T:System.DateTime"/> using the <see cref="T:System.DateTime"/> <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.#ctor(System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="format">The format string.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> class \r
+            with the specified format string.\r
+            </para>\r
+            <para>\r
+            The format string must be compatible with the options\r
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.DateFormatter.SimpleDateFormatter.FormatDate(System.DateTime,System.IO.TextWriter)">\r
+            <summary>\r
+            Formats the date using <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.\r
+            </summary>\r
+            <param name="dateToFormat">The date to convert to a string.</param>\r
+            <param name="writer">The writer to write to.</param>\r
+            <remarks>\r
+            <para>\r
+            Uses the date format string supplied to the constructor to call\r
+            the <see cref="M:DateTime.ToString(string, IFormatProvider)"/> method to format the date.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.DateFormatter.SimpleDateFormatter.m_formatString">\r
+            <summary>\r
+            The format string used to format the <see cref="T:System.DateTime"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The format string must be compatible with the options\r
+            that can be supplied to <see cref="M:DateTime.ToString(string, IFormatProvider)"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Filter.DenyAllFilter">\r
+            <summary>\r
+            This filter drops all <see cref="T:log4net.Core.LoggingEvent"/>. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            You can add this filter to the end of a filter chain to\r
+            switch from the default "accept all unless instructed otherwise"\r
+            filtering behavior to a "deny all unless instructed otherwise"\r
+            behavior.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Filter.FilterSkeleton">\r
+            <summary>\r
+            Subclass this type to implement customized logging event filtering\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Users should extend this class to implement customized logging\r
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and \r
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard\r
+            appenders, have built-in filtering rules. It is suggested that you\r
+            first use and understand the built-in rules before rushing to write\r
+            your own custom filters.\r
+            </para>\r
+            <para>\r
+            This abstract class assumes and also imposes that filters be\r
+            organized in a linear chain. The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/>\r
+            method of each filter is called sequentially, in the order of their \r
+            addition to the chain.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)"/> method must return one\r
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, \r
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.\r
+            </para>\r
+            <para>\r
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped \r
+            immediately without consulting with the remaining filters.\r
+            </para>\r
+            <para>\r
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter\r
+            in the chain is consulted. If there are no more filters in the\r
+            chain, then the log event is logged. Thus, in the presence of no\r
+            filters, the default behavior is to log all logging events.\r
+            </para>\r
+            <para>\r
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log\r
+            event is logged without consulting the remaining filters.\r
+            </para>\r
+            <para>\r
+            The philosophy of log4net filters is largely inspired from the\r
+            Linux ipchains.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Filter.IFilter">\r
+            <summary>\r
+            Implement this interface to provide customized logging event filtering\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Users should implement this interface to implement customized logging\r
+            event filtering. Note that <see cref="T:log4net.Repository.Hierarchy.Logger"/> and \r
+            <see cref="T:log4net.Appender.AppenderSkeleton"/>, the parent class of all standard\r
+            appenders, have built-in filtering rules. It is suggested that you\r
+            first use and understand the built-in rules before rushing to write\r
+            your own custom filters.\r
+            </para>\r
+            <para>\r
+            This abstract class assumes and also imposes that filters be\r
+            organized in a linear chain. The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>\r
+            method of each filter is called sequentially, in the order of their \r
+            addition to the chain.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/> method must return one\r
+            of the integer constants <see cref="F:log4net.Filter.FilterDecision.Deny"/>, \r
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> or <see cref="F:log4net.Filter.FilterDecision.Accept"/>.\r
+            </para>\r
+            <para>\r
+            If the value <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned, then the log event is dropped \r
+            immediately without consulting with the remaining filters.\r
+            </para>\r
+            <para>\r
+            If the value <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned, then the next filter\r
+            in the chain is consulted. If there are no more filters in the\r
+            chain, then the log event is logged. Thus, in the presence of no\r
+            filters, the default behavior is to log all logging events.\r
+            </para>\r
+            <para>\r
+            If the value <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, then the log\r
+            event is logged without consulting the remaining filters.\r
+            </para>\r
+            <para>\r
+            The philosophy of log4net filters is largely inspired from the\r
+            Linux ipchains.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Decide if the logging event should be logged through an appender.\r
+            </summary>\r
+            <param name="loggingEvent">The LoggingEvent to decide upon</param>\r
+            <returns>The decision of the filter</returns>\r
+            <remarks>\r
+            <para>\r
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be\r
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next\r
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then\r
+            the event will be logged without consulting with other filters in\r
+            the chain.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.IFilter.Next">\r
+            <summary>\r
+            Property to get and set the next filter\r
+            </summary>\r
+            <value>\r
+            The next filter in the chain\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Filters are typically composed into chains. This property allows the next filter in \r
+            the chain to be accessed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Filter.FilterSkeleton.m_next">\r
+            <summary>\r
+            Points to the next filter in the filter chain.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Filter.FilterSkeleton.Next"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Filter.FilterSkeleton.ActivateOptions">\r
+            <summary>\r
+            Initialize the filter with the options set\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Filter.FilterSkeleton.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            Typically filter's options become active immediately on set, \r
+            however this method must still be called. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Filter.FilterSkeleton.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Decide if the <see cref="T:log4net.Core.LoggingEvent"/> should be logged through an appender.\r
+            </summary>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> to decide upon</param>\r
+            <returns>The decision of the filter</returns>\r
+            <remarks>\r
+            <para>\r
+            If the decision is <see cref="F:log4net.Filter.FilterDecision.Deny"/>, then the event will be\r
+            dropped. If the decision is <see cref="F:log4net.Filter.FilterDecision.Neutral"/>, then the next\r
+            filter, if any, will be invoked. If the decision is <see cref="F:log4net.Filter.FilterDecision.Accept"/> then\r
+            the event will be logged without consulting with other filters in\r
+            the chain.\r
+            </para>\r
+            <para>\r
+            This method is marked <c>abstract</c> and must be implemented\r
+            in a subclass.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.FilterSkeleton.Next">\r
+            <summary>\r
+            Property to get and set the next filter\r
+            </summary>\r
+            <value>\r
+            The next filter in the chain\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Filters are typically composed into chains. This property allows the next filter in \r
+            the chain to be accessed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Filter.DenyAllFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.DenyAllFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Always returns the integer constant <see cref="F:log4net.Filter.FilterDecision.Deny"/>\r
+            </summary>\r
+            <param name="loggingEvent">the LoggingEvent to filter</param>\r
+            <returns>Always returns <see cref="F:log4net.Filter.FilterDecision.Deny"/></returns>\r
+            <remarks>\r
+            <para>\r
+            Ignores the event being logged and just returns\r
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This can be used to change the default filter\r
+            chain behavior from <see cref="F:log4net.Filter.FilterDecision.Accept"/> to <see cref="F:log4net.Filter.FilterDecision.Deny"/>. This filter\r
+            should only be used as the last filter in the chain\r
+            as any further filters will be ignored!\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Filter.FilterDecision">\r
+            <summary>\r
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The return result from <see cref="M:log4net.Filter.IFilter.Decide(log4net.Core.LoggingEvent)"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Filter.FilterDecision.Deny">\r
+            <summary>\r
+            The log event must be dropped immediately without \r
+            consulting with the remaining filters, if any, in the chain.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.FilterDecision.Neutral">\r
+            <summary>\r
+            This filter is neutral with respect to the log event. \r
+            The remaining filters, if any, should be consulted for a final decision.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.FilterDecision.Accept">\r
+            <summary>\r
+            The log event must be logged immediately without \r
+            consulting with the remaining filters, if any, in the chain.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Filter.LevelMatchFilter">\r
+            <summary>\r
+            This is a very simple filter based on <see cref="T:log4net.Core.Level"/> matching.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The filter admits two options <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> and\r
+            <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If there is an exact match between the value\r
+            of the <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/> option and the <see cref="T:log4net.Core.Level"/> of the \r
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the <see cref="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in \r
+            case the <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> option value is set\r
+            to <c>true</c>, if it is <c>false</c> then \r
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If the <see cref="T:log4net.Core.Level"/> does not match then\r
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Filter.LevelMatchFilter.m_acceptOnMatch">\r
+            <summary>\r
+            flag to indicate if the filter should <see cref="F:log4net.Filter.FilterDecision.Accept"/> on a match\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.LevelMatchFilter.m_levelToMatch">\r
+            <summary>\r
+            the <see cref="T:log4net.Core.Level"/> to match against\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.LevelMatchFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.LevelMatchFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Tests if the <see cref="T:log4net.Core.Level"/> of the logging event matches that of the filter\r
+            </summary>\r
+            <param name="loggingEvent">the event to filter</param>\r
+            <returns>see remarks</returns>\r
+            <remarks>\r
+            <para>\r
+            If the <see cref="T:log4net.Core.Level"/> of the event matches the level of the\r
+            filter then the result of the function depends on the\r
+            value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>. If it is true then\r
+            the function will return <see cref="F:log4net.Filter.FilterDecision.Accept"/>, it it is false then it\r
+            will return <see cref="F:log4net.Filter.FilterDecision.Deny"/>. If the <see cref="T:log4net.Core.Level"/> does not match then\r
+            the result will be <see cref="F:log4net.Filter.FilterDecision.Neutral"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch">\r
+            <summary>\r
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelMatchFilter.LevelToMatch"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/> property is a flag that determines\r
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the\r
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the \r
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.\r
+            </para>\r
+            <para>\r
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LevelMatchFilter.LevelToMatch">\r
+            <summary>\r
+            The <see cref="T:log4net.Core.Level"/> that the filter will match\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The level that this filter will attempt to match against the \r
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then\r
+            the result depends on the value of <see cref="P:log4net.Filter.LevelMatchFilter.AcceptOnMatch"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Filter.LevelRangeFilter">\r
+            <summary>\r
+            This is a simple filter based on <see cref="T:log4net.Core.Level"/> matching.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The filter admits three options <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>\r
+            that determine the range of priorities that are matched, and\r
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>. If there is a match between the range\r
+            of priorities and the <see cref="T:log4net.Core.Level"/> of the <see cref="T:log4net.Core.LoggingEvent"/>, then the \r
+            <see cref="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in case the <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> \r
+            option value is set to <c>true</c>, if it is <c>false</c>\r
+            then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned. If there is no match, <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Filter.LevelRangeFilter.m_acceptOnMatch">\r
+            <summary>\r
+            Flag to indicate the behavior when matching a <see cref="T:log4net.Core.Level"/>\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMin">\r
+            <summary>\r
+            the minimum <see cref="T:log4net.Core.Level"/> value to match\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.LevelRangeFilter.m_levelMax">\r
+            <summary>\r
+            the maximum <see cref="T:log4net.Core.Level"/> value to match\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.LevelRangeFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.LevelRangeFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Check if the event should be logged.\r
+            </summary>\r
+            <param name="loggingEvent">the logging event to check</param>\r
+            <returns>see remarks</returns>\r
+            <remarks>\r
+            <para>\r
+            If the <see cref="T:log4net.Core.Level"/> of the logging event is outside the range\r
+            matched by this filter then <see cref="F:log4net.Filter.FilterDecision.Deny"/>\r
+            is returned. If the <see cref="T:log4net.Core.Level"/> is matched then the value of\r
+            <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> is checked. If it is true then\r
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned, otherwise\r
+            <see cref="F:log4net.Filter.FilterDecision.Neutral"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch">\r
+            <summary>\r
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LevelRangeFilter.LevelMin"/> and <see cref="P:log4net.Filter.LevelRangeFilter.LevelMax"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/> property is a flag that determines\r
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the\r
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the \r
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.\r
+            </para>\r
+            <para>\r
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMin">\r
+            <summary>\r
+            Set the minimum matched <see cref="T:log4net.Core.Level"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The minimum level that this filter will attempt to match against the \r
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then\r
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LevelRangeFilter.LevelMax">\r
+            <summary>\r
+            Sets the maximum matched <see cref="T:log4net.Core.Level"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The maximum level that this filter will attempt to match against the \r
+            <see cref="T:log4net.Core.LoggingEvent"/> level. If a match is found then\r
+            the result depends on the value of <see cref="P:log4net.Filter.LevelRangeFilter.AcceptOnMatch"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Filter.LoggerMatchFilter">\r
+            <summary>\r
+            Simple filter to match a string in the event's logger name.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The works very similar to the <see cref="T:log4net.Filter.LevelMatchFilter"/>. It admits two \r
+            options <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> and <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>. If the \r
+            <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <see cref="T:log4net.Core.LoggingEvent"/> starts \r
+            with the value of the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> option, then the \r
+            <see cref="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)"/> method returns <see cref="F:log4net.Filter.FilterDecision.Accept"/> in \r
+            case the <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> option value is set to <c>true</c>, \r
+            if it is <c>false</c> then <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.\r
+            </para>\r
+            </remarks>\r
+            <author>Daniel Cazzulino</author>\r
+        </member>\r
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_acceptOnMatch">\r
+            <summary>\r
+            Flag to indicate the behavior when we have a match\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.LoggerMatchFilter.m_loggerToMatch">\r
+            <summary>\r
+            The logger name string to substring match against the event\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.LoggerMatchFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.LoggerMatchFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Check if this filter should allow the event to be logged\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <returns>see remarks</returns>\r
+            <remarks>\r
+            <para>\r
+            The rendered message is matched against the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>.\r
+            If the <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/> equals the beginning of \r
+            the incoming <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> (<see cref="M:String.StartsWith(string)"/>)\r
+            then a match will have occurred. If no match occurs\r
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>\r
+            allowing other filters to check the event. If a match occurs then\r
+            the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> is checked. If it is\r
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise\r
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch">\r
+            <summary>\r
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/> property is a flag that determines\r
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the\r
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the \r
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Deny"/> the event.\r
+            </para>\r
+            <para>\r
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.LoggerMatchFilter.LoggerToMatch">\r
+            <summary>\r
+            The <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> that the filter will match\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This filter will attempt to match this value against logger name in\r
+            the following way. The match will be done against the beginning of the\r
+            logger name (using <see cref="M:String.StartsWith(string)"/>). The match is\r
+            case sensitive. If a match is found then\r
+            the result depends on the value of <see cref="P:log4net.Filter.LoggerMatchFilter.AcceptOnMatch"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Filter.MdcFilter">\r
+            <summary>\r
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Simple filter to match a keyed string in the <see cref="T:log4net.MDC"/>\r
+            </para>\r
+            <para>\r
+            As the MDC has been replaced with layered properties the\r
+            <see cref="T:log4net.Filter.PropertyFilter"/> should be used instead.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Filter.PropertyFilter">\r
+            <summary>\r
+            Simple filter to match a string an event property\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Simple filter to match a string in the value for a\r
+            specific event property\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="T:log4net.Filter.StringMatchFilter">\r
+            <summary>\r
+            Simple filter to match a string in the rendered message\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Simple filter to match a string in the rendered message\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Filter.StringMatchFilter.m_acceptOnMatch">\r
+            <summary>\r
+            Flag to indicate the behavior when we have a match\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringToMatch">\r
+            <summary>\r
+            The string to substring match against the message\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.StringMatchFilter.m_stringRegexToMatch">\r
+            <summary>\r
+            A string regex to match\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Filter.StringMatchFilter.m_regexToMatch">\r
+            <summary>\r
+            A regex object to match (generated from m_stringRegexToMatch)\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.StringMatchFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.StringMatchFilter.ActivateOptions">\r
+            <summary>\r
+            Initialize and precompile the Regex if required\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Filter.StringMatchFilter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Filter.StringMatchFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Check if this filter should allow the event to be logged\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <returns>see remarks</returns>\r
+            <remarks>\r
+            <para>\r
+            The rendered message is matched against the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.\r
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within\r
+            the message then a match will have occurred. If no match occurs\r
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>\r
+            allowing other filters to check the event. If a match occurs then\r
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is\r
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise\r
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.StringMatchFilter.AcceptOnMatch">\r
+            <summary>\r
+            <see cref="F:log4net.Filter.FilterDecision.Accept"/> when matching <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> property is a flag that determines\r
+            the behavior when a matching <see cref="T:log4net.Core.Level"/> is found. If the\r
+            flag is set to true then the filter will <see cref="F:log4net.Filter.FilterDecision.Accept"/> the \r
+            logging event, otherwise it will <see cref="F:log4net.Filter.FilterDecision.Neutral"/> the event.\r
+            </para>\r
+            <para>\r
+            The default is <c>true</c> i.e. to <see cref="F:log4net.Filter.FilterDecision.Accept"/> the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.StringMatchFilter.StringToMatch">\r
+            <summary>\r
+            Sets the static string to match\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The string that will be substring matched against\r
+            the rendered message. If the message contains this\r
+            string then the filter will match. If a match is found then\r
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.\r
+            </para>\r
+            <para>\r
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>\r
+            must be specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.StringMatchFilter.RegexToMatch">\r
+            <summary>\r
+            Sets the regular expression to match\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The regular expression pattern that will be matched against\r
+            the rendered message. If the message matches this\r
+            pattern then the filter will match. If a match is found then\r
+            the result depends on the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/>.\r
+            </para>\r
+            <para>\r
+            One of <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> or <see cref="P:log4net.Filter.StringMatchFilter.RegexToMatch"/>\r
+            must be specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Filter.PropertyFilter.m_key">\r
+            <summary>\r
+            The key to use to lookup the string from the event properties\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.PropertyFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Filter.PropertyFilter.Decide(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Check if this filter should allow the event to be logged\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <returns>see remarks</returns>\r
+            <remarks>\r
+            <para>\r
+            The event property for the <see cref="P:log4net.Filter.PropertyFilter.Key"/> is matched against \r
+            the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/>.\r
+            If the <see cref="P:log4net.Filter.StringMatchFilter.StringToMatch"/> occurs as a substring within\r
+            the property value then a match will have occurred. If no match occurs\r
+            this function will return <see cref="F:log4net.Filter.FilterDecision.Neutral"/>\r
+            allowing other filters to check the event. If a match occurs then\r
+            the value of <see cref="P:log4net.Filter.StringMatchFilter.AcceptOnMatch"/> is checked. If it is\r
+            true then <see cref="F:log4net.Filter.FilterDecision.Accept"/> is returned otherwise\r
+            <see cref="F:log4net.Filter.FilterDecision.Deny"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Filter.PropertyFilter.Key">\r
+            <summary>\r
+            The key to lookup in the event properties and then match against.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The key name to use to lookup in the properties map of the\r
+            <see cref="T:log4net.Core.LoggingEvent"/>. The match will be performed against \r
+            the value of this property if it exists.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Filter.NdcFilter">\r
+            <summary>\r
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Simple filter to match a string in the <see cref="T:log4net.NDC"/>\r
+            </para>\r
+            <para>\r
+            As the MDC has been replaced with named stacks stored in the\r
+            properties collections the <see cref="T:log4net.Filter.PropertyFilter"/> should \r
+            be used instead.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Filter.NdcFilter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Sets the <see cref="P:log4net.Filter.PropertyFilter.Key"/> to <c>"NDC"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.AppDomainPatternConverter">\r
+            <summary>\r
+            Write the event appdomain name to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Daniel Cazzulino</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.PatternLayoutConverter">\r
+            <summary>\r
+            Abstract class that provides the formatting functionality that \r
+            derived classes need.\r
+            </summary>\r
+            <remarks>\r
+            Conversion specifiers in a conversion patterns are parsed to\r
+            individual PatternConverters. Each of which is responsible for\r
+            converting a logging event in a converter specific manner.\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternConverter">\r
+            <summary>\r
+            Abstract class that provides the formatting functionality that \r
+            derived classes need.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Conversion specifiers in a conversion patterns are parsed to\r
+            individual PatternConverters. Each of which is responsible for\r
+            converting a logging event in a converter specific manner.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferSize">\r
+            <summary>\r
+            Initial buffer size\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternConverter.c_renderBufferMaxCapacity">\r
+            <summary>\r
+            Maximum buffer size before it is recycled\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.#ctor">\r
+            <summary>\r
+            Protected constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternConverter"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Evaluate this pattern converter and write the output to a writer.\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">The state object on which the pattern converter should be executed.</param>\r
+            <remarks>\r
+            <para>\r
+            Derived pattern converters must override this method in order to\r
+            convert conversion specifiers in the appropriate way.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.SetNext(log4net.Util.PatternConverter)">\r
+            <summary>\r
+            Set the next pattern converter in the chains\r
+            </summary>\r
+            <param name="patternConverter">the pattern converter that should follow this converter in the chain</param>\r
+            <returns>the next converter</returns>\r
+            <remarks>\r
+            <para>\r
+            The PatternConverter can merge with its neighbor during this method (or a sub class).\r
+            Therefore the return value may or may not be the value of the argument passed in.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.Format(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the pattern converter to the writer with appropriate formatting\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">The state object on which the pattern converter should be executed.</param>\r
+            <remarks>\r
+            <para>\r
+            This method calls <see cref="M:log4net.Util.PatternConverter.Convert(System.IO.TextWriter,System.Object)"/> to allow the subclass to perform\r
+            appropriate conversion of the pattern converter. If formatting options have\r
+            been specified via the <see cref="P:log4net.Util.PatternConverter.FormattingInfo"/> then this method will\r
+            apply those formattings before writing the output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.SpacePad(System.IO.TextWriter,System.Int32)">\r
+            <summary>\r
+            Fast space padding method.\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> to which the spaces will be appended.</param>\r
+            <param name="length">The number of spaces to be padded.</param>\r
+            <remarks>\r
+            <para>\r
+            Fast space padding method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternConverter.m_option">\r
+            <summary>\r
+            The option string to the converter\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionary)">\r
+            <summary>\r
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>\r
+            <param name="value">the value to write to the writer</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="T:System.Collections.IDictionary"/> to a writer in the form:\r
+            </para>\r
+            <code>\r
+            {key1=value1, key2=value2, key3=value3}\r
+            </code>\r
+            <para>\r
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified\r
+            is not null then it is used to render the key and value to text, otherwise\r
+            the object's ToString method is called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.WriteDictionary(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Collections.IDictionaryEnumerator)">\r
+            <summary>\r
+            Write an dictionary to a <see cref="T:System.IO.TextWriter"/>\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>\r
+            <param name="value">the value to write to the writer</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="T:System.Collections.IDictionaryEnumerator"/> to a writer in the form:\r
+            </para>\r
+            <code>\r
+            {key1=value1, key2=value2, key3=value3}\r
+            </code>\r
+            <para>\r
+            If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified\r
+            is not null then it is used to render the key and value to text, otherwise\r
+            the object's ToString method is called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternConverter.WriteObject(System.IO.TextWriter,log4net.Repository.ILoggerRepository,System.Object)">\r
+            <summary>\r
+            Write an object to a <see cref="T:System.IO.TextWriter"/>\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="repository">a <see cref="T:log4net.Repository.ILoggerRepository"/> to use for object conversion</param>\r
+            <param name="value">the value to write to the writer</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the Object to a writer. If the <see cref="T:log4net.Repository.ILoggerRepository"/> specified\r
+            is not null then it is used to render the object to text, otherwise\r
+            the object's ToString method is called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PatternConverter.Next">\r
+            <summary>\r
+            Get the next pattern converter in the chain\r
+            </summary>\r
+            <value>\r
+            the next pattern converter in the chain\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Get the next pattern converter in the chain\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PatternConverter.FormattingInfo">\r
+            <summary>\r
+            Gets or sets the formatting info for this converter\r
+            </summary>\r
+            <value>\r
+            The formatting info for this converter\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the formatting info for this converter\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PatternConverter.Option">\r
+            <summary>\r
+            Gets or sets the option value for this converter\r
+            </summary>\r
+            <summary>\r
+            The option for this converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the option value for this converter\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PatternConverter.Properties">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Layout.Pattern.PatternLayoutConverter"/> class.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Derived pattern converters must override this method in order to\r
+            convert conversion specifiers in the correct way.\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.PatternLayoutConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Derived pattern converters must override this method in order to\r
+            convert conversion specifiers in the correct way.\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">The state object on which the pattern converter should be executed.</param>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.PatternLayoutConverter.m_ignoresException">\r
+            <summary>\r
+            Flag indicating if this converter handles exceptions\r
+            </summary>\r
+            <remarks>\r
+            <c>false</c> if this converter handles exceptions\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.Pattern.PatternLayoutConverter.IgnoresException">\r
+            <summary>\r
+            Flag indicating if this converter handles the logging event exception\r
+            </summary>\r
+            <value><c>false</c> if this converter handles the logging event exception</value>\r
+            <remarks>\r
+            <para>\r
+            If this converter handles the exception object contained within\r
+            <see cref="T:log4net.Core.LoggingEvent"/>, then this property should be set to\r
+            <c>false</c>. Otherwise, if the layout ignores the exception\r
+            object, then the property should be set to <c>true</c>.\r
+            </para>\r
+            <para>\r
+            Set this value to override a this default setting. The default\r
+            value is <c>true</c>, this converter does not handle the exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.AppDomainPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the event appdomain name to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LoggingEvent.Domain"/> to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.AspNetCachePatternConverter">\r
+            <summary>\r
+            Converter for items in the ASP.Net Cache.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.AspNetPatternLayoutConverter">\r
+            <summary>\r
+            Abstract class that provides access to the current HttpContext (<see cref="P:System.Web.HttpContext.Current"/>) that \r
+            derived classes need.\r
+            </summary>\r
+            <remarks>\r
+            This class handles the case when HttpContext.Current is null by writing\r
+            <see cref="P:log4net.Util.SystemInfo.NotAvailableText"/> to the writer.\r
+            </remarks>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.AspNetPatternLayoutConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">\r
+            <summary>\r
+            Derived pattern converters must override this method in order to\r
+            convert conversion specifiers in the correct way.\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>\r
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.AspNetCachePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">\r
+            <summary>\r
+            Write the ASP.Net Cache item to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>\r
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property. If no property has been set, all key value pairs from the Cache will\r
+            be written to the output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.AspNetContextPatternConverter">\r
+            <summary>\r
+            Converter for items in the <see cref="T:System.Web.HttpContext"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs an item from the <see cref="T:System.Web.HttpContext"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.AspNetContextPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">\r
+            <summary>\r
+            Write the ASP.Net HttpContext item to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>\r
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.AspNetRequestPatternConverter">\r
+            <summary>\r
+            Converter for items in the ASP.Net Cache.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.AspNetRequestPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">\r
+            <summary>\r
+            Write the ASP.Net Cache item to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>\r
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.AspNetSessionPatternConverter">\r
+            <summary>\r
+            Converter for items in the ASP.Net Cache.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs an item from the <see cref="P:System.Web.HttpRuntime.Cache"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.AspNetSessionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent,System.Web.HttpContext)">\r
+            <summary>\r
+            Write the ASP.Net Cache item to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">The <see cref="T:log4net.Core.LoggingEvent"/> on which the pattern converter should be executed.</param>\r
+            <param name="httpContext">The <see cref="T:System.Web.HttpContext"/> under which the ASP.Net request is running.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property. If no property has been set, all key value pairs from the Session will\r
+            be written to the output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.DatePatternConverter">\r
+            <summary>\r
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format \r
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Render the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the writer as a string.\r
+            </para>\r
+            <para>\r
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines \r
+            the formatting of the date. The following values are allowed:\r
+            <list type="definition">\r
+               <listheader>\r
+                       <term>Option value</term>\r
+                       <description>Output</description>\r
+               </listheader>\r
+               <item>\r
+                       <term>ISO8601</term>\r
+                       <description>\r
+                       Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. \r
+                       Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>DATE</term>\r
+                       <description>\r
+                       Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. \r
+                       Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>ABSOLUTE</term>\r
+                       <description>\r
+                       Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. \r
+                       Formats using the <c>"HH:mm:ss,yyyy"</c> for example, <c>"15:49:37,459"</c>.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>other</term>\r
+                       <description>\r
+                       Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. \r
+                       This formatter passes the pattern string to the <see cref="T:System.DateTime"/> \r
+                       <see cref="M:DateTime.ToString(string)"/> method.\r
+                       For details on valid patterns see \r
+                       <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> is in the local time zone and is rendered in that zone.\r
+            To output the time in Universal time see <see cref="T:log4net.Layout.Pattern.UtcDatePatternConverter"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.m_dateFormatter">\r
+            <summary>\r
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions">\r
+            <summary>\r
+            Initialize the converter pattern based on the <see cref="P:log4net.Util.PatternConverter.Option"/> property.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.Pattern.DatePatternConverter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.DatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Convert the pattern into the rendered message\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>\r
+            for it to render it to the writer.\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.DatePatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the DatePatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.ExceptionPatternConverter">\r
+            <summary>\r
+            Write the exception text to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If an exception object is stored in the logging event\r
+            it will be rendered into the pattern output with a\r
+            trailing newline.\r
+            </para>\r
+            <para>\r
+            If there is no exception then nothing will be output\r
+            and no trailing newline will be appended.\r
+            It is typical to put a newline before the exception\r
+            and to have the exception as the last data in the pattern.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.ExceptionPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the exception text to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            If an exception object is stored in the logging event\r
+            it will be rendered into the pattern output with a\r
+            trailing newline.\r
+            </para>\r
+            <para>\r
+            If there is no exception or the exception property specified\r
+            by the Option value does not exist then nothing will be output\r
+            and no trailing newline will be appended.\r
+            It is typical to put a newline before the exception\r
+            and to have the exception as the last data in the pattern.\r
+            </para>\r
+            <para>\r
+            Recognized values for the Option parameter are:\r
+            </para>\r
+            <list type="bullet">\r
+               <item>\r
+                       <description>Message</description>\r
+               </item>\r
+               <item>\r
+                       <description>Source</description>\r
+               </item>\r
+               <item>\r
+                       <description>StackTrace</description>\r
+               </item>\r
+               <item>\r
+                       <description>TargetSite</description>\r
+               </item>\r
+               <item>\r
+                       <description>HelpLink</description>\r
+               </item>         \r
+            </list>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.FileLocationPatternConverter">\r
+            <summary>\r
+            Writes the caller location file name to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for\r
+            the event to the output writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.FileLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the caller location file name to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.FileName"/> for\r
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.FullLocationPatternConverter">\r
+            <summary>\r
+            Write the caller location info to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.FullLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the caller location info to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LocationInfo.FullInfo"/> to the output writer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.IdentityPatternConverter">\r
+            <summary>\r
+            Writes the event identity to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the value of the <see cref="P:log4net.Core.LoggingEvent.Identity"/> to\r
+            the output writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Daniel Cazzulino</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.IdentityPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Writes the event identity to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the value of the <paramref name="loggingEvent"/> \r
+            <see cref="P:log4net.Core.LoggingEvent.Identity"/> to\r
+            the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.LevelPatternConverter">\r
+            <summary>\r
+            Write the event level to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the display name of the event <see cref="P:log4net.Core.LoggingEvent.Level"/>\r
+            to the writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.LevelPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the event level to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.Level.DisplayName"/> of the <paramref name="loggingEvent"/> <see cref="P:log4net.Core.LoggingEvent.Level"/>\r
+            to the <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.LineLocationPatternConverter">\r
+            <summary>\r
+            Write the caller location line number to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for\r
+            the event to the output writer.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.LineLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the caller location line number to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the value of the <see cref="P:log4net.Core.LocationInfo.LineNumber"/> for\r
+            the <paramref name="loggingEvent"/> to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.LoggerPatternConverter">\r
+            <summary>\r
+            Converter for logger name\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the event.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.NamedPatternConverter">\r
+            <summary>\r
+            Converter to output and truncate <c>'.'</c> separated strings\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This abstract class supports truncating a <c>'.'</c> separated string\r
+            to show a specified number of elements from the right hand side.\r
+            This is used to truncate class names that are fully qualified.\r
+            </para>\r
+            <para>\r
+            Subclasses should override the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> method to\r
+            return the fully qualified string.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions">\r
+            <summary>\r
+            Initialize the converter \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Get the fully qualified string data\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <returns>the fully qualified name</returns>\r
+            <remarks>\r
+            <para>\r
+            Overridden by subclasses to get the fully qualified name before the\r
+            precision is applied to it.\r
+            </para>\r
+            <para>\r
+            Return the fully qualified <c>'.'</c> (dot/period) separated string.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.NamedPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Convert the pattern to the rendered message\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            Render the <see cref="M:log4net.Layout.Pattern.NamedPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)"/> to the precision\r
+            specified by the <see cref="P:log4net.Util.PatternConverter.Option"/> property.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.NamedPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the NamedPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.LoggerPatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Gets the fully qualified name of the logger\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <returns>The fully qualified logger name</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the <see cref="P:log4net.Core.LoggingEvent.LoggerName"/> of the <paramref name="loggingEvent"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.MessagePatternConverter">\r
+            <summary>\r
+            Writes the event message to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method\r
+            to write out the event message.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.MessagePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Writes the event message to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:log4net.Core.LoggingEvent.WriteRenderedMessage(System.IO.TextWriter)"/> method\r
+            to write out the event message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.MethodLocationPatternConverter">\r
+            <summary>\r
+            Write the method name to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to\r
+            the output.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.MethodLocationPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the method name to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the caller location <see cref="P:log4net.Core.LocationInfo.MethodName"/> to\r
+            the output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.NdcPatternConverter">\r
+            <summary>\r
+            Converter to include event NDC\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs the value of the event property named <c>NDC</c>.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.NdcPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the event NDC to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            As the thread context stacks are now stored in named event properties\r
+            this converter simply looks up the value of the <c>NDC</c> property.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Layout.Pattern.PropertyPatternConverter"/> should be used instead.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.PropertyPatternConverter">\r
+            <summary>\r
+            Property pattern converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            <para>\r
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>\r
+            then all the properties are written as key value pairs.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.PropertyPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the property value to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            <para>\r
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>\r
+            then all the properties are written as key value pairs.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.RelativeTimePatternConverter">\r
+            <summary>\r
+            Converter to output the relative time of the event\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Converter to output the time of the event relative to the start of the program.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the relative time to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the relative time of the event in milliseconds.\r
+            That is the number of milliseconds between the event <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/>\r
+            and the <see cref="P:log4net.Core.LoggingEvent.StartTime"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.RelativeTimePatternConverter.TimeDifferenceInMillis(System.DateTime,System.DateTime)">\r
+            <summary>\r
+            Helper method to get the time difference between two DateTime objects\r
+            </summary>\r
+            <param name="start">start time (in the current local time zone)</param>\r
+            <param name="end">end time (in the current local time zone)</param>\r
+            <returns>the time difference in milliseconds</returns>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.StackTraceDetailPatternConverter">\r
+            <summary>\r
+            Write the caller stack frames to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:\r
+            type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)\r
+            </para>\r
+            </remarks>\r
+            <author>Adam Davies</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.StackTracePatternConverter">\r
+            <summary>\r
+            Write the caller stack frames to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer, using format:\r
+            type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1\r
+            </para>\r
+            </remarks>\r
+            <author>Michael Cromwell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions">\r
+            <summary>\r
+            Initialize the converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.Pattern.StackTracePatternConverter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the strack frames to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LocationInfo.StackFrames"/> to the output writer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.StackTracePatternConverter.GetMethodInformation(log4net.Core.MethodItem)">\r
+            <summary>\r
+            Returns the Name of the method\r
+            </summary>\r
+            <param name="method"></param>\r
+            <remarks>This method was created, so this class could be used as a base class for StackTraceDetailPatternConverter</remarks>\r
+            <returns>string</returns>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.StackTracePatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the StackTracePatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.StackTraceDetailPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the StackTraceDetailPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.ThreadPatternConverter">\r
+            <summary>\r
+            Converter to include event thread name\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the output.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.ThreadPatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the ThreadName to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the <see cref="P:log4net.Core.LoggingEvent.ThreadName"/> to the <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.TypeNamePatternConverter">\r
+            <summary>\r
+            Pattern converter for the class name\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Outputs the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the event.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.TypeNamePatternConverter.GetFullyQualifiedName(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Gets the fully qualified name of the class\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <returns>The fully qualified type name for the caller location</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the <see cref="P:log4net.Core.LocationInfo.ClassName"/> of the <paramref name="loggingEvent"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.UserNamePatternConverter">\r
+            <summary>\r
+            Converter to include event user name\r
+            </summary>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.UserNamePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Convert the pattern to the rendered message\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+        </member>\r
+        <member name="T:log4net.Layout.Pattern.UtcDatePatternConverter">\r
+            <summary>\r
+            Write the TimeStamp to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format \r
+            the date of a <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </para>\r
+            <para>\r
+            Uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> \r
+            in Universal time.\r
+            </para>\r
+            <para>\r
+            See the <see cref="T:log4net.Layout.Pattern.DatePatternConverter"/> for details on the date pattern syntax.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.Pattern.UtcDatePatternConverter.Convert(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Write the TimeStamp to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Pass the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>\r
+            for it to render it to the writer.\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> passed is in the local time zone, this is converted\r
+            to Universal time before it is rendered.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Layout.Pattern.DatePatternConverter"/>\r
+        </member>\r
+        <member name="F:log4net.Layout.Pattern.UtcDatePatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the UtcDatePatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.DynamicPatternLayout">\r
+            <summary>\r
+            A flexible layout configurable with pattern string that re-evaluates on each call.\r
+            </summary>\r
+            <remarks>\r
+            <para>This class is built on <see cref="T:log4net.Layout.PatternLayout"></see> and provides all the\r
+            features and capabilities of PatternLayout.  PatternLayout is a 'static' class\r
+            in that its layout is done once at configuration time.  This class will recreate\r
+            the layout on each reference.</para>\r
+            <para>One important difference between PatternLayout and DynamicPatternLayout is the\r
+            treatment of the Header and Footer parameters in the configuration.  The Header and Footer\r
+            parameters for DynamicPatternLayout must be syntactically in the form of a PatternString,\r
+            but should not be marked as type log4net.Util.PatternString.  Doing so causes the\r
+            pattern to be statically converted at configuration time and causes DynamicPatternLayout\r
+            to perform the same as PatternLayout.</para>\r
+            <para>Please see <see cref="T:log4net.Layout.PatternLayout"/> for complete documentation.</para>\r
+            <example>\r
+            &lt;layout type="log4net.Layout.DynamicPatternLayout"&gt;\r
+              &lt;param name="Header" value="%newline**** Trace Opened     Local: %date{yyyy-MM-dd HH:mm:ss.fff}     UTC: %utcdate{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;\r
+              &lt;param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline" /&gt;\r
+            &lt;/layout&gt;\r
+            </example>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.PatternLayout">\r
+            <summary>\r
+            A flexible layout configurable with pattern string.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The goal of this class is to <see cref="M:PatternLayout.Format(TextWriter,LoggingEvent)"/> a \r
+            <see cref="T:log4net.Core.LoggingEvent"/> as a string. The results\r
+            depend on the <i>conversion pattern</i>.\r
+            </para>\r
+            <para>\r
+            The conversion pattern is closely related to the conversion\r
+            pattern of the printf function in C. A conversion pattern is\r
+            composed of literal text and format control expressions called\r
+            <i>conversion specifiers</i>.\r
+            </para>\r
+            <para>\r
+            <i>You are free to insert any literal text within the conversion\r
+            pattern.</i>\r
+            </para>\r
+            <para>\r
+            Each conversion specifier starts with a percent sign (%) and is\r
+            followed by optional <i>format modifiers</i> and a <i>conversion\r
+            pattern name</i>. The conversion pattern name specifies the type of\r
+            data, e.g. logger, level, date, thread name. The format\r
+            modifiers control such things as field width, padding, left and\r
+            right justification. The following is a simple example.\r
+            </para>\r
+            <para>\r
+            Let the conversion pattern be <b>"%-5level [%thread]: %message%newline"</b> and assume\r
+            that the log4net environment was set to use a PatternLayout. Then the\r
+            statements\r
+            </para>\r
+            <code lang="C#">\r
+            ILog log = LogManager.GetLogger(typeof(TestApp));\r
+            log.Debug("Message 1");\r
+            log.Warn("Message 2");   \r
+            </code>\r
+            <para>would yield the output</para>\r
+            <code>\r
+            DEBUG [main]: Message 1\r
+            WARN  [main]: Message 2  \r
+            </code>\r
+            <para>\r
+            Note that there is no explicit separator between text and\r
+            conversion specifiers. The pattern parser knows when it has reached\r
+            the end of a conversion specifier when it reads a conversion\r
+            character. In the example above the conversion specifier\r
+            <b>%-5level</b> means the level of the logging event should be left\r
+            justified to a width of five characters.\r
+            </para>\r
+            <para>\r
+            The recognized conversion pattern names are:\r
+            </para>\r
+            <list type="table">\r
+                <listheader>\r
+                    <term>Conversion Pattern Name</term>\r
+                    <description>Effect</description>\r
+                </listheader>\r
+                <item>\r
+                    <term>a</term>\r
+                    <description>Equivalent to <b>appdomain</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>appdomain</term>\r
+                    <description>\r
+                               Used to output the friendly name of the AppDomain where the \r
+                               logging event was generated. \r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>aspnet-cache</term>\r
+                    <description>\r
+                        <para>\r
+                        Used to output all cache items in the case of <b>%aspnet-cache</b> or just one named item if used as <b>%aspnet-cache{key}</b>\r
+                        </para>\r
+                        <para>\r
+                        This pattern is not available for Compact Framework or Client Profile assemblies.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>aspnet-context</term>\r
+                    <description>\r
+                        <para>\r
+                        Used to output all context items in the case of <b>%aspnet-context</b> or just one named item if used as <b>%aspnet-context{key}</b>\r
+                        </para>\r
+                        <para>\r
+                        This pattern is not available for Compact Framework or Client Profile assemblies.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>aspnet-request</term>\r
+                    <description>\r
+                        <para>\r
+                        Used to output all request parameters in the case of <b>%aspnet-request</b> or just one named param if used as <b>%aspnet-request{key}</b>\r
+                        </para>\r
+                        <para>\r
+                        This pattern is not available for Compact Framework or Client Profile assemblies.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>aspnet-session</term>\r
+                    <description>\r
+                        <para>\r
+                        Used to output all session items in the case of <b>%aspnet-session</b> or just one named item if used as <b>%aspnet-session{key}</b>\r
+                        </para>\r
+                        <para>\r
+                        This pattern is not available for Compact Framework or Client Profile assemblies.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>c</term>\r
+                    <description>Equivalent to <b>logger</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>C</term>\r
+                    <description>Equivalent to <b>type</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>class</term>\r
+                    <description>Equivalent to <b>type</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>d</term>\r
+                    <description>Equivalent to <b>date</b></description>\r
+                </item>\r
+                <item>\r
+                       <term>date</term> \r
+                       <description>\r
+                               <para>\r
+                               Used to output the date of the logging event in the local time zone. \r
+                               To output the date in universal time use the <c>%utcdate</c> pattern.\r
+                               The date conversion \r
+                               specifier may be followed by a <i>date format specifier</i> enclosed \r
+                               between braces. For example, <b>%date{HH:mm:ss,fff}</b> or\r
+                               <b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is \r
+                               given then ISO8601 format is\r
+                               assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).\r
+                               </para>\r
+                               <para>\r
+                               The date format specifier admits the same syntax as the\r
+                               time pattern string of the <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                               <para>\r
+                               For better results it is recommended to use the log4net date\r
+                               formatters. These can be specified using one of the strings\r
+                               "ABSOLUTE", "DATE" and "ISO8601" for specifying \r
+                               <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, \r
+                               <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively \r
+                               <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, \r
+                               <b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.\r
+                               </para>\r
+                               <para>\r
+                               These dedicated date formatters perform significantly\r
+                               better than <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>exception</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the exception passed in with the log message.\r
+                               </para>\r
+                               <para>\r
+                               If an exception object is stored in the logging event\r
+                               it will be rendered into the pattern output with a\r
+                               trailing newline.\r
+                               If there is no exception then nothing will be output\r
+                               and no trailing newline will be appended.\r
+                               It is typical to put a newline before the exception\r
+                               and to have the exception as the last data in the pattern.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>F</term>\r
+                    <description>Equivalent to <b>file</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>file</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the file name where the logging request was\r
+                               issued.\r
+                               </para>\r
+                               <para>\r
+                               <b>WARNING</b> Generating caller location information is\r
+                               extremely slow. Its use should be avoided unless execution speed\r
+                               is not an issue.\r
+                               </para>\r
+                               <para>\r
+                               See the note below on the availability of caller location information.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>identity</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the user name for the currently active user\r
+                               (Principal.Identity.Name).\r
+                               </para>\r
+                               <para>\r
+                               <b>WARNING</b> Generating caller information is\r
+                               extremely slow. Its use should be avoided unless execution speed\r
+                               is not an issue.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>l</term>\r
+                    <description>Equivalent to <b>location</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>L</term>\r
+                    <description>Equivalent to <b>line</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>location</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output location information of the caller which generated\r
+                               the logging event.\r
+                               </para>\r
+                               <para>\r
+                               The location information depends on the CLI implementation but\r
+                               usually consists of the fully qualified name of the calling\r
+                               method followed by the callers source the file name and line\r
+                               number between parentheses.\r
+                               </para>\r
+                               <para>\r
+                               The location information can be very useful. However, its\r
+                               generation is <b>extremely</b> slow. Its use should be avoided\r
+                               unless execution speed is not an issue.\r
+                               </para>\r
+                               <para>\r
+                               See the note below on the availability of caller location information.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>level</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the level of the logging event.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>line</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the line number from where the logging request\r
+                               was issued.\r
+                               </para>\r
+                               <para>\r
+                               <b>WARNING</b> Generating caller location information is\r
+                               extremely slow. Its use should be avoided unless execution speed\r
+                               is not an issue.\r
+                               </para>\r
+                               <para>\r
+                               See the note below on the availability of caller location information.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>logger</term>\r
+                    <description>\r
+                        <para>\r
+                               Used to output the logger of the logging event. The\r
+                               logger conversion specifier can be optionally followed by\r
+                               <i>precision specifier</i>, that is a decimal constant in\r
+                               brackets.\r
+                        </para>\r
+                               <para>\r
+                               If a precision specifier is given, then only the corresponding\r
+                               number of right most components of the logger name will be\r
+                               printed. By default the logger name is printed in full.\r
+                               </para>\r
+                               <para>\r
+                               For example, for the logger name "a.b.c" the pattern\r
+                               <b>%logger{2}</b> will output "b.c".\r
+                               </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>m</term>\r
+                    <description>Equivalent to <b>message</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>M</term>\r
+                    <description>Equivalent to <b>method</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>message</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the application supplied message associated with \r
+                               the logging event.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>mdc</term>\r
+                       <description>\r
+                               <para>\r
+                               The MDC (old name for the ThreadContext.Properties) is now part of the\r
+                               combined event properties. This pattern is supported for compatibility\r
+                               but is equivalent to <b>property</b>.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>method</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the method name where the logging request was\r
+                               issued.\r
+                               </para>\r
+                               <para>\r
+                               <b>WARNING</b> Generating caller location information is\r
+                               extremely slow. Its use should be avoided unless execution speed\r
+                               is not an issue.\r
+                               </para>\r
+                               <para>\r
+                               See the note below on the availability of caller location information.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>n</term>\r
+                    <description>Equivalent to <b>newline</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>newline</term>\r
+                       <description>\r
+                               <para>\r
+                               Outputs the platform dependent line separator character or\r
+                               characters.\r
+                               </para>\r
+                               <para>\r
+                               This conversion pattern offers the same performance as using \r
+                               non-portable line separator strings such as     "\n", or "\r\n". \r
+                               Thus, it is the preferred way of specifying a line separator.\r
+                               </para> \r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>ndc</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the NDC (nested diagnostic context) associated\r
+                               with the thread that generated the logging event.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>p</term>\r
+                    <description>Equivalent to <b>level</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>P</term>\r
+                    <description>Equivalent to <b>property</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>properties</term>\r
+                    <description>Equivalent to <b>property</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>property</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the an event specific property. The key to \r
+                               lookup must be specified within braces and directly following the\r
+                               pattern specifier, e.g. <b>%property{user}</b> would include the value\r
+                               from the property that is keyed by the string 'user'. Each property value\r
+                               that is to be included in the log must be specified separately.\r
+                               Properties are added to events by loggers or appenders. By default \r
+                               the <c>log4net:HostName</c> property is set to the name of machine on \r
+                               which the event was originally logged.\r
+                               </para>\r
+                               <para>\r
+                               If no key is specified, e.g. <b>%property</b> then all the keys and their\r
+                               values are printed in a comma separated list.\r
+                               </para>\r
+                               <para>\r
+                               The properties of an event are combined from a number of different\r
+                               contexts. These are listed below in the order in which they are searched.\r
+                               </para>\r
+                               <list type="definition">\r
+                                       <item>\r
+                                               <term>the event properties</term>\r
+                                               <description>\r
+                                               The event has <see cref="P:log4net.Core.LoggingEvent.Properties"/> that can be set. These \r
+                                               properties are specific to this event only.\r
+                                               </description>\r
+                                       </item>\r
+                                       <item>\r
+                                               <term>the thread properties</term>\r
+                                               <description>\r
+                                               The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current\r
+                                               thread. These properties are shared by all events logged on this thread.\r
+                                               </description>\r
+                                       </item>\r
+                                       <item>\r
+                                               <term>the global properties</term>\r
+                                               <description>\r
+                                               The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These \r
+                                               properties are shared by all the threads in the AppDomain.\r
+                                               </description>\r
+                                       </item>\r
+                               </list>\r
+                               \r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>r</term>\r
+                    <description>Equivalent to <b>timestamp</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>stacktrace</term> \r
+                       <description>\r
+                               <para>\r
+                               Used to output the stack trace of the logging event\r
+                               The stack trace level specifier may be enclosed \r
+                               between braces. For example, <b>%stacktrace{level}</b>.  \r
+                               If no stack trace level specifier is given then 1 is assumed \r
+                               </para>\r
+                               <para>\r
+                               Output uses the format:\r
+                               type3.MethodCall3 &gt; type2.MethodCall2 &gt; type1.MethodCall1\r
+                               </para>\r
+                        <para>\r
+                        This pattern is not available for Compact Framework assemblies.\r
+                        </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>stacktracedetail</term> \r
+                       <description>\r
+                               <para>\r
+                               Used to output the stack trace of the logging event\r
+                               The stack trace level specifier may be enclosed \r
+                               between braces. For example, <b>%stacktracedetail{level}</b>.  \r
+                               If no stack trace level specifier is given then 1 is assumed \r
+                               </para>\r
+                               <para>\r
+                               Output uses the format:\r
+                        type3.MethodCall3(type param,...) &gt; type2.MethodCall2(type param,...) &gt; type1.MethodCall1(type param,...)\r
+                               </para>\r
+                        <para>\r
+                        This pattern is not available for Compact Framework assemblies.\r
+                        </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>t</term>\r
+                    <description>Equivalent to <b>thread</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>timestamp</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the number of milliseconds elapsed since the start\r
+                               of the application until the creation of the logging event.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>thread</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the name of the thread that generated the\r
+                               logging event. Uses the thread number if no name is available.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                       <term>type</term> \r
+                       <description>\r
+                               <para>\r
+                               Used to output the fully qualified type name of the caller\r
+                               issuing the logging request. This conversion specifier\r
+                               can be optionally followed by <i>precision specifier</i>, that\r
+                               is a decimal constant in brackets.\r
+                               </para>\r
+                               <para>\r
+                               If a precision specifier is given, then only the corresponding\r
+                               number of right most components of the class name will be\r
+                               printed. By default the class name is output in fully qualified form.\r
+                               </para>\r
+                               <para>\r
+                               For example, for the class name "log4net.Layout.PatternLayout", the\r
+                               pattern <b>%type{1}</b> will output "PatternLayout".\r
+                               </para>\r
+                               <para>\r
+                               <b>WARNING</b> Generating the caller class information is\r
+                               slow. Thus, its use should be avoided unless execution speed is\r
+                               not an issue.\r
+                               </para>\r
+                               <para>\r
+                               See the note below on the availability of caller location information.\r
+                               </para>\r
+                       </description>\r
+                </item>\r
+                <item>\r
+                    <term>u</term>\r
+                    <description>Equivalent to <b>identity</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>username</term>\r
+                       <description>\r
+                               <para>\r
+                               Used to output the WindowsIdentity for the currently\r
+                               active user.\r
+                               </para>\r
+                               <para>\r
+                               <b>WARNING</b> Generating caller WindowsIdentity information is\r
+                               extremely slow. Its use should be avoided unless execution speed\r
+                               is not an issue.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                       <term>utcdate</term> \r
+                       <description>\r
+                               <para>\r
+                               Used to output the date of the logging event in universal time. \r
+                               The date conversion \r
+                               specifier may be followed by a <i>date format specifier</i> enclosed \r
+                               between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or\r
+                               <b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is \r
+                               given then ISO8601 format is\r
+                               assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).\r
+                               </para>\r
+                               <para>\r
+                               The date format specifier admits the same syntax as the\r
+                               time pattern string of the <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                               <para>\r
+                               For better results it is recommended to use the log4net date\r
+                               formatters. These can be specified using one of the strings\r
+                               "ABSOLUTE", "DATE" and "ISO8601" for specifying \r
+                               <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, \r
+                               <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively \r
+                               <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, \r
+                               <b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.\r
+                               </para>\r
+                               <para>\r
+                               These dedicated date formatters perform significantly\r
+                               better than <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+                <item>\r
+                    <term>w</term>\r
+                    <description>Equivalent to <b>username</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>x</term>\r
+                    <description>Equivalent to <b>ndc</b></description>\r
+                </item>\r
+                <item>\r
+                    <term>X</term>\r
+                    <description>Equivalent to <b>mdc</b></description>\r
+                </item>\r
+               <item>\r
+                       <term>%</term>\r
+                       <description>\r
+                               <para>\r
+                               The sequence %% outputs a single percent sign.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            <para>\r
+            The single letter patterns are deprecated in favor of the \r
+            longer more descriptive pattern names.\r
+            </para>\r
+            <para>\r
+            By default the relevant information is output as is. However,\r
+            with the aid of format modifiers it is possible to change the\r
+            minimum field width, the maximum field width and justification.\r
+            </para>\r
+            <para>\r
+            The optional format modifier is placed between the percent sign\r
+            and the conversion pattern name.\r
+            </para>\r
+            <para>\r
+            The first optional format modifier is the <i>left justification\r
+            flag</i> which is just the minus (-) character. Then comes the\r
+            optional <i>minimum field width</i> modifier. This is a decimal\r
+            constant that represents the minimum number of characters to\r
+            output. If the data item requires fewer characters, it is padded on\r
+            either the left or the right until the minimum width is\r
+            reached. The default is to pad on the left (right justify) but you\r
+            can specify right padding with the left justification flag. The\r
+            padding character is space. If the data item is larger than the\r
+            minimum field width, the field is expanded to accommodate the\r
+            data. The value is never truncated.\r
+            </para>\r
+            <para>\r
+            This behavior can be changed using the <i>maximum field\r
+            width</i> modifier which is designated by a period followed by a\r
+            decimal constant. If the data item is longer than the maximum\r
+            field, then the extra characters are removed from the\r
+            <i>beginning</i> of the data item and not from the end. For\r
+            example, it the maximum field width is eight and the data item is\r
+            ten characters long, then the first two characters of the data item\r
+            are dropped. This behavior deviates from the printf function in C\r
+            where truncation is done from the end.\r
+            </para>\r
+            <para>\r
+            Below are various format modifier examples for the logger\r
+            conversion specifier.\r
+            </para>\r
+            <div class="tablediv">\r
+               <table class="dtTABLE" cellspacing="0">\r
+                       <tr>\r
+                               <th>Format modifier</th>\r
+                               <th>left justify</th>\r
+                               <th>minimum width</th>\r
+                               <th>maximum width</th>\r
+                               <th>comment</th>\r
+                       </tr>\r
+                       <tr>\r
+                               <td align="center">%20logger</td>\r
+                               <td align="center">false</td>\r
+                               <td align="center">20</td>\r
+                               <td align="center">none</td>\r
+                               <td>\r
+                                       <para>\r
+                                       Left pad with spaces if the logger name is less than 20\r
+                                       characters long.\r
+                                       </para>\r
+                               </td>\r
+                       </tr>\r
+                       <tr>\r
+                               <td align="center">%-20logger</td>\r
+                               <td align="center">true</td>\r
+                               <td align="center">20</td>\r
+                               <td align="center">none</td>\r
+                               <td>\r
+                                       <para>\r
+                                       Right pad with spaces if the logger \r
+                                       name is less than 20 characters long.\r
+                                       </para>\r
+                               </td>\r
+                       </tr>\r
+                       <tr>\r
+                               <td align="center">%.30logger</td>\r
+                               <td align="center">NA</td>\r
+                               <td align="center">none</td>\r
+                               <td align="center">30</td>\r
+                               <td>\r
+                                       <para>\r
+                                       Truncate from the beginning if the logger \r
+                                       name is longer than 30 characters.\r
+                                       </para>\r
+                               </td>\r
+                       </tr>\r
+                       <tr>\r
+                               <td align="center"><nobr>%20.30logger</nobr></td>\r
+                               <td align="center">false</td>\r
+                               <td align="center">20</td>\r
+                               <td align="center">30</td>\r
+                               <td>\r
+                                       <para>\r
+                                       Left pad with spaces if the logger name is shorter than 20\r
+                                       characters. However, if logger name is longer than 30 characters,\r
+                                       then truncate from the beginning.\r
+                                       </para>\r
+                               </td>\r
+                       </tr>\r
+                       <tr>\r
+                               <td align="center">%-20.30logger</td>\r
+                               <td align="center">true</td>\r
+                               <td align="center">20</td>\r
+                               <td align="center">30</td>\r
+                               <td>\r
+                                       <para>\r
+                                       Right pad with spaces if the logger name is shorter than 20\r
+                                       characters. However, if logger name is longer than 30 characters,\r
+                                       then truncate from the beginning.\r
+                                       </para>\r
+                               </td>\r
+                       </tr>\r
+               </table>\r
+            </div>\r
+            <para>\r
+            <b>Note about caller location information.</b><br/>\r
+            The following patterns <c>%type %file %line %method %location %class %C %F %L %l %M</c> \r
+            all generate caller location information.\r
+            Location information uses the <c>System.Diagnostics.StackTrace</c> class to generate\r
+            a call stack. The caller's information is then extracted from this stack.\r
+            </para>\r
+            <note type="caution">\r
+            <para>\r
+            The <c>System.Diagnostics.StackTrace</c> class is not supported on the \r
+            .NET Compact Framework 1.0 therefore caller location information is not\r
+            available on that framework.\r
+            </para>\r
+            </note>\r
+            <note type="caution">\r
+            <para>\r
+            The <c>System.Diagnostics.StackTrace</c> class has this to say about Release builds:\r
+            </para>\r
+            <para>\r
+            "StackTrace information will be most informative with Debug build configurations. \r
+            By default, Debug builds include debug symbols, while Release builds do not. The \r
+            debug symbols contain most of the file, method name, line number, and column \r
+            information used in constructing StackFrame and StackTrace objects. StackTrace \r
+            might not report as many method calls as expected, due to code transformations \r
+            that occur during optimization."\r
+            </para>\r
+            <para>\r
+            This means that in a Release build the caller information may be incomplete or may \r
+            not exist at all! Therefore caller location information cannot be relied upon in a Release build.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Layout.PatternLayout"/>\r
+            instance using the <see cref="M:AddConverter(string, Type)"/> method.\r
+            </para>\r
+            </remarks>\r
+            <example>\r
+            This is a more detailed pattern.\r
+            <code><b>%timestamp [%thread] %level %logger %ndc - %message%newline</b></code>\r
+            </example>\r
+            <example>\r
+            A similar pattern except that the relative time is\r
+            right padded if less than 6 digits, thread name is right padded if\r
+            less than 15 characters and truncated if longer and the logger\r
+            name is left padded if shorter than 30 characters and truncated if\r
+            longer.\r
+            <code><b>%-6timestamp [%15.15thread] %-5level %30.30logger %ndc - %message%newline</b></code>\r
+            </example>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Douglas de la Torre</author>\r
+            <author>Daniel Cazzulino</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.LayoutSkeleton">\r
+            <summary>\r
+            Extend this abstract class to create your own log layout format.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is the base implementation of the <see cref="T:log4net.Layout.ILayout"/>\r
+            interface. Most layout objects should extend this class.\r
+            </para>\r
+            </remarks>\r
+            <remarks>\r
+            <note type="inheritinfo">\r
+            <para>\r
+            Subclasses must implement the <see cref="M:Format(TextWriter,LoggingEvent)"/>\r
+            method.\r
+            </para>\r
+            <para>\r
+            Subclasses should set the <see cref="P:log4net.Layout.LayoutSkeleton.IgnoresException"/> in their default\r
+            constructor.\r
+            </para>\r
+            </note>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.ILayout">\r
+            <summary>\r
+            Interface implemented by layout objects\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            An <see cref="T:log4net.Layout.ILayout"/> object is used to format a <see cref="T:log4net.Core.LoggingEvent"/>\r
+            as text. The <see cref="M:Format(TextWriter,LoggingEvent)"/> method is called by an\r
+            appender to transform the <see cref="T:log4net.Core.LoggingEvent"/> into a string.\r
+            </para>\r
+            <para>\r
+            The layout can also supply <see cref="P:log4net.Layout.ILayout.Header"/> and <see cref="P:log4net.Layout.ILayout.Footer"/>\r
+            text that is appender before any events and after all the events respectively.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.ILayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Implement this method to create your own layout format.\r
+            </summary>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <remarks>\r
+            <para>\r
+            This method is called by an appender to format\r
+            the <paramref name="loggingEvent"/> as text and output to a writer.\r
+            </para>\r
+            <para>\r
+            If the caller does not have a <see cref="T:System.IO.TextWriter"/> and prefers the\r
+            event to be formatted as a <see cref="T:System.String"/> then the following\r
+            code can be used to format the event into a <see cref="T:System.IO.StringWriter"/>.\r
+            </para>\r
+            <code lang="C#">\r
+            StringWriter writer = new StringWriter();\r
+            Layout.Format(writer, loggingEvent);\r
+            string formattedEvent = writer.ToString();\r
+            </code>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.ILayout.ContentType">\r
+            <summary>\r
+            The content type output by this layout. \r
+            </summary>\r
+            <value>The content type</value>\r
+            <remarks>\r
+            <para>\r
+            The content type output by this layout.\r
+            </para>\r
+            <para>\r
+            This is a MIME type e.g. <c>"text/plain"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.ILayout.Header">\r
+            <summary>\r
+            The header for the layout format.\r
+            </summary>\r
+            <value>the layout header</value>\r
+            <remarks>\r
+            <para>\r
+            The Header text will be appended before any logging events\r
+            are formatted and appended.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.ILayout.Footer">\r
+            <summary>\r
+            The footer for the layout format.\r
+            </summary>\r
+            <value>the layout footer</value>\r
+            <remarks>\r
+            <para>\r
+            The Footer text will be appended after all the logging events\r
+            have been formatted and appended.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.ILayout.IgnoresException">\r
+            <summary>\r
+            Flag indicating if this layout handle exceptions\r
+            </summary>\r
+            <value><c>false</c> if this layout handles exceptions</value>\r
+            <remarks>\r
+            <para>\r
+            If this layout handles the exception object contained within\r
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return\r
+            <c>false</c>. Otherwise, if the layout ignores the exception\r
+            object, then the layout should return <c>true</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.LayoutSkeleton.m_header">\r
+            <summary>\r
+            The header text\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Header"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.LayoutSkeleton.m_footer">\r
+            <summary>\r
+            The footer text\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            See <see cref="P:log4net.Layout.LayoutSkeleton.Footer"/> for more information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.LayoutSkeleton.m_ignoresException">\r
+            <summary>\r
+            Flag indicating if this layout handles exceptions\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <c>false</c> if this layout handles exceptions\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.LayoutSkeleton.#ctor">\r
+            <summary>\r
+            Empty default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Empty default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.LayoutSkeleton.ActivateOptions">\r
+            <summary>\r
+            Activate component options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.LayoutSkeleton.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            This method must be implemented by the subclass.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Implement this method to create your own layout format.\r
+            </summary>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <remarks>\r
+            <para>\r
+            This method is called by an appender to format\r
+            the <paramref name="loggingEvent"/> as text.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.LayoutSkeleton.Format(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Convenience method for easily formatting the logging event into a string variable.\r
+            </summary>\r
+            <param name="loggingEvent"></param>\r
+            <remarks>\r
+            Creates a new StringWriter instance to store the formatted logging event.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.LayoutSkeleton.ContentType">\r
+            <summary>\r
+            The content type output by this layout. \r
+            </summary>\r
+            <value>The content type is <c>"text/plain"</c></value>\r
+            <remarks>\r
+            <para>\r
+            The content type output by this layout.\r
+            </para>\r
+            <para>\r
+            This base class uses the value <c>"text/plain"</c>.\r
+            To change this value a subclass must override this\r
+            property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.LayoutSkeleton.Header">\r
+            <summary>\r
+            The header for the layout format.\r
+            </summary>\r
+            <value>the layout header</value>\r
+            <remarks>\r
+            <para>\r
+            The Header text will be appended before any logging events\r
+            are formatted and appended.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.LayoutSkeleton.Footer">\r
+            <summary>\r
+            The footer for the layout format.\r
+            </summary>\r
+            <value>the layout footer</value>\r
+            <remarks>\r
+            <para>\r
+            The Footer text will be appended after all the logging events\r
+            have been formatted and appended.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.LayoutSkeleton.IgnoresException">\r
+            <summary>\r
+            Flag indicating if this layout handles exceptions\r
+            </summary>\r
+            <value><c>false</c> if this layout handles exceptions</value>\r
+            <remarks>\r
+            <para>\r
+            If this layout handles the exception object contained within\r
+            <see cref="T:log4net.Core.LoggingEvent"/>, then the layout should return\r
+            <c>false</c>. Otherwise, if the layout ignores the exception\r
+            object, then the layout should return <c>true</c>.\r
+            </para>\r
+            <para>\r
+            Set this value to override a this default setting. The default\r
+            value is <c>true</c>, this layout does not handle the exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.PatternLayout.DefaultConversionPattern">\r
+            <summary>\r
+            Default pattern string for log output. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default pattern string for log output. \r
+            Currently set to the string <b>"%message%newline"</b> \r
+            which just prints the application supplied message. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.PatternLayout.DetailConversionPattern">\r
+            <summary>\r
+            A detailed conversion pattern\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A conversion pattern which includes Time, Thread, Logger, and Nested Context.\r
+            Current value is <b>%timestamp [%thread] %level %logger %ndc - %message%newline</b>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.PatternLayout.s_globalRulesRegistry">\r
+            <summary>\r
+            Internal map of converter identifiers to converter types.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This static map is overridden by the m_converterRegistry instance map\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.PatternLayout.m_pattern">\r
+            <summary>\r
+            the pattern\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Layout.PatternLayout.m_head">\r
+            <summary>\r
+            the head of the pattern converter chain\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Layout.PatternLayout.m_instanceRulesRegistry">\r
+            <summary>\r
+            patterns defined on this PatternLayout only\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.#cctor">\r
+            <summary>\r
+            Initialize the global registry\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Defines the builtin global rules.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.#ctor">\r
+            <summary>\r
+            Constructs a PatternLayout using the DefaultConversionPattern\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The default pattern just produces the application supplied message.\r
+            </para>\r
+            <para>\r
+            Note to Inheritors: This constructor calls the virtual method\r
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be\r
+            aware that it will be called before your is called constructor.\r
+            </para>\r
+            <para>\r
+            As per the <see cref="T:log4net.Core.IOptionHandler"/> contract the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>\r
+            method must be called after the properties on this object have been\r
+            configured.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.#ctor(System.String)">\r
+            <summary>\r
+            Constructs a PatternLayout using the supplied conversion pattern\r
+            </summary>\r
+            <param name="pattern">the pattern to use</param>\r
+            <remarks>\r
+            <para>\r
+            Note to Inheritors: This constructor calls the virtual method\r
+            <see cref="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)"/>. If you override this method be\r
+            aware that it will be called before your is called constructor.\r
+            </para>\r
+            <para>\r
+            When using this constructor the <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method \r
+            need not be called. This may not be the case when using a subclass.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.CreatePatternParser(System.String)">\r
+            <summary>\r
+            Create the pattern parser instance\r
+            </summary>\r
+            <param name="pattern">the pattern to parse</param>\r
+            <returns>The <see cref="T:log4net.Util.PatternParser"/> that will format the event</returns>\r
+            <remarks>\r
+            <para>\r
+            Creates the <see cref="T:log4net.Util.PatternParser"/> used to parse the conversion string. Sets the\r
+            global and instance rules on the <see cref="T:log4net.Util.PatternParser"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.ActivateOptions">\r
+            <summary>\r
+            Initialize layout options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Produces a formatted string as specified by the conversion pattern.\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <remarks>\r
+            <para>\r
+            Parse the <see cref="T:log4net.Core.LoggingEvent"/> using the patter format\r
+            specified in the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(log4net.Util.ConverterInfo)">\r
+            <summary>\r
+            Add a converter to this PatternLayout\r
+            </summary>\r
+            <param name="converterInfo">the converter info</param>\r
+            <remarks>\r
+            <para>\r
+            This version of the method is used by the configurator.\r
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.PatternLayout.AddConverter(System.String,System.Type)">\r
+            <summary>\r
+            Add a converter to this PatternLayout\r
+            </summary>\r
+            <param name="name">the name of the conversion pattern for this converter</param>\r
+            <param name="type">the type of the converter</param>\r
+            <remarks>\r
+            <para>\r
+            Add a named pattern converter to this instance. This\r
+            converter will be used in the formatting of the event.\r
+            This method must be called before <see cref="M:log4net.Layout.PatternLayout.ActivateOptions"/>.\r
+            </para>\r
+            <para>\r
+            The <paramref name="type"/> specified must extend the \r
+            <see cref="T:log4net.Util.PatternConverter"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.PatternLayout.ConversionPattern">\r
+            <summary>\r
+            The pattern formatting string\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <b>ConversionPattern</b> option. This is the string which\r
+            controls formatting and consists of a mix of literal content and\r
+            conversion specifiers.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_headerPatternString">\r
+            <summary>\r
+            The header PatternString\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Layout.DynamicPatternLayout.m_footerPatternString">\r
+            <summary>\r
+            The footer PatternString\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor">\r
+            <summary>\r
+            Constructs a DynamicPatternLayout using the DefaultConversionPattern\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The default pattern just produces the application supplied message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.DynamicPatternLayout.#ctor(System.String)">\r
+            <summary>\r
+            Constructs a DynamicPatternLayout using the supplied conversion pattern\r
+            </summary>\r
+            <param name="pattern">the pattern to use</param>\r
+            <remarks>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.DynamicPatternLayout.Header">\r
+            <summary>\r
+            The header for the layout format.\r
+            </summary>\r
+            <value>the layout header</value>\r
+            <remarks>\r
+            <para>\r
+            The Header text will be appended before any logging events\r
+            are formatted and appended.\r
+            </para>\r
+            The pattern will be formatted on each get operation.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.DynamicPatternLayout.Footer">\r
+            <summary>\r
+            The footer for the layout format.\r
+            </summary>\r
+            <value>the layout footer</value>\r
+            <remarks>\r
+            <para>\r
+            The Footer text will be appended after all the logging events\r
+            have been formatted and appended.\r
+            </para>\r
+            The pattern will be formatted on each get operation.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.ExceptionLayout">\r
+            <summary>\r
+            A Layout that renders only the Exception text from the logging event\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A Layout that renders only the Exception text from the logging event.\r
+            </para>\r
+            <para>\r
+            This Layout should only be used with appenders that utilize multiple\r
+            layouts (e.g. <see cref="T:log4net.Appender.AdoNetAppender"/>).\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.ExceptionLayout.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Constructs a ExceptionLayout\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.ExceptionLayout.ActivateOptions">\r
+            <summary>\r
+            Activate component options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Part of the <see cref="T:log4net.Core.IOptionHandler"/> component activation\r
+            framework.\r
+            </para>\r
+            <para>\r
+            This method does nothing as options become effective immediately.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.ExceptionLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Gets the exception text from the logging event\r
+            </summary>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <remarks>\r
+            <para>\r
+            Write the exception string to the <see cref="T:System.IO.TextWriter"/>.\r
+            The exception string is retrieved from <see cref="M:LoggingEvent.GetExceptionString()"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.IRawLayout">\r
+            <summary>\r
+            Interface for raw layout objects\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface used to format a <see cref="T:log4net.Core.LoggingEvent"/>\r
+            to an object.\r
+            </para>\r
+            <para>\r
+            This interface should not be confused with the\r
+            <see cref="T:log4net.Layout.ILayout"/> interface. This interface is used in\r
+            only certain specialized situations where a raw object is\r
+            required rather than a formatted string. The <see cref="T:log4net.Layout.ILayout"/>\r
+            is not generally useful than this interface.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.IRawLayout.Format(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Implement this method to create your own layout format.\r
+            </summary>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <returns>returns the formatted event</returns>\r
+            <remarks>\r
+            <para>\r
+            Implement this method to create your own layout format.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.Layout2RawLayoutAdapter">\r
+            <summary>\r
+            Adapts any <see cref="T:log4net.Layout.ILayout"/> to a <see cref="T:log4net.Layout.IRawLayout"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Where an <see cref="T:log4net.Layout.IRawLayout"/> is required this adapter\r
+            allows a <see cref="T:log4net.Layout.ILayout"/> to be specified.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Layout.Layout2RawLayoutAdapter.m_layout">\r
+            <summary>\r
+            The layout to adapt\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.#ctor(log4net.Layout.ILayout)">\r
+            <summary>\r
+            Construct a new adapter\r
+            </summary>\r
+            <param name="layout">the layout to adapt</param>\r
+            <remarks>\r
+            <para>\r
+            Create the adapter for the specified <paramref name="layout"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.Layout2RawLayoutAdapter.Format(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Format the logging event as an object.\r
+            </summary>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <returns>returns the formatted event</returns>\r
+            <remarks>\r
+            <para>\r
+            Format the logging event as an object.\r
+            </para>\r
+            <para>\r
+            Uses the <see cref="T:log4net.Layout.ILayout"/> object supplied to \r
+            the constructor to perform the formatting.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.RawLayoutConverter">\r
+            <summary>\r
+            Type converter for the <see cref="T:log4net.Layout.IRawLayout"/> interface\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Used to convert objects to the <see cref="T:log4net.Layout.IRawLayout"/> interface.\r
+            Supports converting from the <see cref="T:log4net.Layout.ILayout"/> interface to\r
+            the <see cref="T:log4net.Layout.IRawLayout"/> interface using the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.IConvertFrom">\r
+            <summary>\r
+            Interface supported by type converters\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This interface supports conversion from arbitrary types\r
+            to a single target type. See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if the <paramref name="sourceType"/> can be converted to the\r
+            type supported by this converter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.IConvertFrom.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Convert the source object to the type supported by this object\r
+            </summary>\r
+            <param name="source">the object to convert</param>\r
+            <returns>the converted object</returns>\r
+            <remarks>\r
+            <para>\r
+            Converts the <paramref name="source"/> to the type supported\r
+            by this converter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawLayoutConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the sourceType be converted to an <see cref="T:log4net.Layout.IRawLayout"/>\r
+            </summary>\r
+            <param name="sourceType">the source to be to be converted</param>\r
+            <returns><c>true</c> if the source type can be converted to <see cref="T:log4net.Layout.IRawLayout"/></returns>\r
+            <remarks>\r
+            <para>\r
+            Test if the <paramref name="sourceType"/> can be converted to a\r
+            <see cref="T:log4net.Layout.IRawLayout"/>. Only <see cref="T:log4net.Layout.ILayout"/> is supported\r
+            as the <paramref name="sourceType"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawLayoutConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Convert the value to a <see cref="T:log4net.Layout.IRawLayout"/> object\r
+            </summary>\r
+            <param name="source">the value to convert</param>\r
+            <returns>the <see cref="T:log4net.Layout.IRawLayout"/> object</returns>\r
+            <remarks>\r
+            <para>\r
+            Convert the <paramref name="source"/> object to a \r
+            <see cref="T:log4net.Layout.IRawLayout"/> object. If the <paramref name="source"/> object\r
+            is a <see cref="T:log4net.Layout.ILayout"/> then the <see cref="T:log4net.Layout.Layout2RawLayoutAdapter"/>\r
+            is used to adapt between the two interfaces, otherwise an\r
+            exception is thrown.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.RawPropertyLayout">\r
+            <summary>\r
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Extract the value of a property from the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawPropertyLayout.#ctor">\r
+            <summary>\r
+            Constructs a RawPropertyLayout\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawPropertyLayout.Format(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Lookup the property for <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>\r
+            </summary>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <returns>returns property value</returns>\r
+            <remarks>\r
+            <para>\r
+            Looks up and returns the object value of the property\r
+            named <see cref="P:log4net.Layout.RawPropertyLayout.Key"/>. If there is no property defined\r
+            with than name then <c>null</c> will be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.RawPropertyLayout.Key">\r
+            <summary>\r
+            The name of the value to lookup in the LoggingEvent Properties collection.\r
+            </summary>\r
+            <value>\r
+            Value to lookup in the LoggingEvent Properties collection\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            String name of the property to lookup in the <see cref="T:log4net.Core.LoggingEvent"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.RawTimeStampLayout">\r
+            <summary>\r
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawTimeStampLayout.#ctor">\r
+            <summary>\r
+            Constructs a RawTimeStampLayout\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawTimeStampLayout.Format(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.\r
+            </summary>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <returns>returns the time stamp</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.\r
+            </para>\r
+            <para>\r
+            The time stamp is in local time. To format the time stamp\r
+            in universal time use <see cref="T:log4net.Layout.RawUtcTimeStampLayout"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.RawUtcTimeStampLayout">\r
+            <summary>\r
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Extract the date from the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.#ctor">\r
+            <summary>\r
+            Constructs a RawUtcTimeStampLayout\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.RawUtcTimeStampLayout.Format(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.\r
+            </summary>\r
+            <param name="loggingEvent">The event to format</param>\r
+            <returns>returns the time stamp</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="P:log4net.Core.LoggingEvent.TimeStamp"/> as a <see cref="T:System.DateTime"/>.\r
+            </para>\r
+            <para>\r
+            The time stamp is in universal time. To format the time stamp\r
+            in local time use <see cref="T:log4net.Layout.RawTimeStampLayout"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.SimpleLayout">\r
+            <summary>\r
+            A very simple layout\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            SimpleLayout consists of the level of the log statement,\r
+            followed by " - " and then the log message itself. For example,\r
+            <code>\r
+            DEBUG - Hello world\r
+            </code>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.SimpleLayout.#ctor">\r
+            <summary>\r
+            Constructs a SimpleLayout\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.SimpleLayout.ActivateOptions">\r
+            <summary>\r
+            Initialize layout options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.SimpleLayout.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.SimpleLayout.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Produces a simple formatted output.\r
+            </summary>\r
+            <param name="loggingEvent">the event being logged</param>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <remarks>\r
+            <para>\r
+            Formats the event as the level of the even,\r
+            followed by " - " and then the log message itself. The\r
+            output is terminated by a newline.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.XmlLayout">\r
+             <summary>\r
+             Layout that formats the log events as XML elements.\r
+             </summary>\r
+             <remarks>\r
+             <para>\r
+             The output of the <see cref="T:log4net.Layout.XmlLayout"/> consists of a series of \r
+             log4net:event elements. It does not output a complete well-formed XML \r
+             file. The output is designed to be included as an <em>external entity</em>\r
+             in a separate file to form a correct XML file.\r
+             </para>\r
+             <para>\r
+             For example, if <c>abc</c> is the name of the file where\r
+             the <see cref="T:log4net.Layout.XmlLayout"/> output goes, then a well-formed XML file would \r
+             be:\r
+             </para>\r
+             <code lang="XML">\r
+             &lt;?xml version="1.0" ?&gt;\r
+             \r
+             &lt;!DOCTYPE log4net:events SYSTEM "log4net-events.dtd" [&lt;!ENTITY data SYSTEM "abc"&gt;]&gt;\r
+            \r
+             &lt;log4net:events version="1.2" xmlns:log4net="http://logging.apache.org/log4net/schemas/log4net-events-1.2&gt;\r
+                 &amp;data;\r
+             &lt;/log4net:events&gt;\r
+             </code>\r
+             <para>\r
+             This approach enforces the independence of the <see cref="T:log4net.Layout.XmlLayout"/> \r
+             and the appender where it is embedded.\r
+             </para>\r
+             <para>\r
+             The <c>version</c> attribute helps components to correctly\r
+             interpret output generated by <see cref="T:log4net.Layout.XmlLayout"/>. The value of \r
+             this attribute should be "1.2" for release 1.2 and later.\r
+             </para>\r
+             <para>\r
+             Alternatively the <c>Header</c> and <c>Footer</c> properties can be\r
+             configured to output the correct XML header, open tag and close tag.\r
+             When setting the <c>Header</c> and <c>Footer</c> properties it is essential\r
+             that the underlying data store not be appendable otherwise the data\r
+             will become invalid XML.\r
+             </para>\r
+             </remarks>\r
+             <author>Nicko Cadell</author>\r
+             <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Layout.XmlLayoutBase">\r
+            <summary>\r
+            Layout that formats the log events as XML elements.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is an abstract class that must be subclassed by an implementation \r
+            to conform to a specific schema.\r
+            </para>\r
+            <para>\r
+            Deriving classes must implement the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor">\r
+            <summary>\r
+            Protected constructor to support subclasses\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Layout.XmlLayoutBase"/> class\r
+            with no location info.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutBase.#ctor(System.Boolean)">\r
+            <summary>\r
+            Protected constructor to support subclasses\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <paramref name="locationInfo" /> parameter determines whether \r
+            location information will be output by the layout. If \r
+            <paramref name="locationInfo" /> is set to <c>true</c>, then the \r
+            file name and line number of the statement at the origin of the log \r
+            statement will be output. \r
+            </para>\r
+            <para>\r
+            If you are embedding this layout within an SMTPAppender\r
+            then make sure to set the <b>LocationInfo</b> option of that \r
+            appender as well.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutBase.ActivateOptions">\r
+            <summary>\r
+            Initialize layout options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.XmlLayoutBase.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutBase.Format(System.IO.TextWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Produces a formatted string.\r
+            </summary>\r
+            <param name="loggingEvent">The event being logged.</param>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <remarks>\r
+            <para>\r
+            Format the <see cref="T:log4net.Core.LoggingEvent"/> and write it to the <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            <para>\r
+            This method creates an <see cref="T:System.Xml.XmlTextWriter"/> that writes to the\r
+            <paramref name="writer"/>. The <see cref="T:System.Xml.XmlTextWriter"/> is passed \r
+            to the <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method. Subclasses should override the\r
+            <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method rather than this method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Does the actual writing of the XML.\r
+            </summary>\r
+            <param name="writer">The writer to use to output the event to.</param>\r
+            <param name="loggingEvent">The event to write.</param>\r
+            <remarks>\r
+            <para>\r
+            Subclasses should override this method to format\r
+            the <see cref="T:log4net.Core.LoggingEvent"/> as XML.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.XmlLayoutBase.m_locationInfo">\r
+            <summary>\r
+            Flag to indicate if location information should be included in\r
+            the XML events.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Layout.XmlLayoutBase.m_invalidCharReplacement">\r
+            <summary>\r
+            The string to replace invalid chars with\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayoutBase.LocationInfo">\r
+            <summary>\r
+            Gets a value indicating whether to include location information in \r
+            the XML events.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if location information should be included in the XML \r
+            events; otherwise, <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If <see cref="P:log4net.Layout.XmlLayoutBase.LocationInfo"/> is set to <c>true</c>, then the file \r
+            name and line number of the statement at the origin of the log \r
+            statement will be output. \r
+            </para>\r
+            <para>\r
+            If you are embedding this layout within an <c>SMTPAppender</c>\r
+            then make sure to set the <b>LocationInfo</b> option of that \r
+            appender as well.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement">\r
+            <summary>\r
+            The string to replace characters that can not be expressed in XML with.\r
+            <remarks>\r
+            <para>\r
+            Not all characters may be expressed in XML. This property contains the\r
+            string to replace those that can not with. This defaults to a ?. Set it\r
+            to the empty string to simply remove offending characters. For more\r
+            details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets\r
+            Character replacement will occur in  the log message, the property names \r
+            and the property values.\r
+            </para>\r
+            </remarks>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayoutBase.ContentType">\r
+            <summary>\r
+            Gets the content type output by this layout. \r
+            </summary>\r
+            <value>\r
+            As this is the XML layout, the value is always <c>"text/xml"</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            As this is the XML layout, the value is always <c>"text/xml"</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayout.#ctor">\r
+            <summary>\r
+            Constructs an XmlLayout\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayout.#ctor(System.Boolean)">\r
+            <summary>\r
+            Constructs an XmlLayout.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <b>LocationInfo</b> option takes a boolean value. By\r
+            default, it is set to false which means there will be no location\r
+            information output by this layout. If the the option is set to\r
+            true, then the file name and line number of the statement\r
+            at the origin of the log statement will be output. \r
+            </para>\r
+            <para>\r
+            If you are embedding this layout within an SmtpAppender\r
+            then make sure to set the <b>LocationInfo</b> option of that \r
+            appender as well.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayout.ActivateOptions">\r
+            <summary>\r
+            Initialize layout options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Layout.XmlLayout.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            Builds a cache of the element names\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayout.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Does the actual writing of the XML.\r
+            </summary>\r
+            <param name="writer">The writer to use to output the event to.</param>\r
+            <param name="loggingEvent">The event to write.</param>\r
+            <remarks>\r
+            <para>\r
+            Override the base class <see cref="M:log4net.Layout.XmlLayoutBase.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)"/> method\r
+            to write the <see cref="T:log4net.Core.LoggingEvent"/> to the <see cref="T:System.Xml.XmlWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Layout.XmlLayout.m_prefix">\r
+            <summary>\r
+            The prefix to use for all generated element names\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayout.Prefix">\r
+            <summary>\r
+            The prefix to use for all element names\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The default prefix is <b>log4net</b>. Set this property\r
+            to change the prefix. If the prefix is set to an empty string\r
+            then no prefix will be written.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeMessage">\r
+            <summary>\r
+            Set whether or not to base64 encode the message.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            By default the log message will be written as text to the xml\r
+            output. This can cause problems when the message contains binary\r
+            data. By setting this to true the contents of the message will be\r
+            base64 encoded. If this is set then invalid character replacement\r
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed\r
+            on the log message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayout.Base64EncodeProperties">\r
+            <summary>\r
+            Set whether or not to base64 encode the property values.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            By default the properties will be written as text to the xml\r
+            output. This can cause problems when one or more properties contain\r
+            binary data. By setting this to true the values of the properties\r
+            will be base64 encoded. If this is set then invalid character replacement\r
+            (see <see cref="P:log4net.Layout.XmlLayoutBase.InvalidCharReplacement"/>) will not be performed\r
+            on the property values.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Layout.XmlLayoutSchemaLog4j">\r
+            <summary>\r
+            Layout that formats the log events as XML elements compatible with the log4j schema\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Formats the log events according to the http://logging.apache.org/log4j schema.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Layout.XmlLayoutSchemaLog4j.s_date1970">\r
+            <summary>\r
+            The 1st of January 1970 in UTC\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor">\r
+            <summary>\r
+            Constructs an XMLLayoutSchemaLog4j\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.#ctor(System.Boolean)">\r
+            <summary>\r
+            Constructs an XMLLayoutSchemaLog4j.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <b>LocationInfo</b> option takes a boolean value. By\r
+            default, it is set to false which means there will be no location\r
+            information output by this layout. If the the option is set to\r
+            true, then the file name and line number of the statement\r
+            at the origin of the log statement will be output. \r
+            </para>\r
+            <para>\r
+            If you are embedding this layout within an SMTPAppender\r
+            then make sure to set the <b>LocationInfo</b> option of that \r
+            appender as well.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Layout.XmlLayoutSchemaLog4j.FormatXml(System.Xml.XmlWriter,log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Actually do the writing of the xml\r
+            </summary>\r
+            <param name="writer">the writer to use</param>\r
+            <param name="loggingEvent">the event to write</param>\r
+            <remarks>\r
+            <para>\r
+            Generate XML that is compatible with the log4j schema.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Layout.XmlLayoutSchemaLog4j.Version">\r
+            <summary>\r
+            The version of the log4j schema to use.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Only version 1.2 of the log4j schema is supported.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.ObjectRenderer.DefaultRenderer">\r
+            <summary>\r
+            The default object Renderer.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The default renderer supports rendering objects and collections to strings.\r
+            </para>\r
+            <para>\r
+            See the <see cref="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)"/> method for details of the output.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.ObjectRenderer.IObjectRenderer">\r
+            <summary>\r
+            Implement this interface in order to render objects as strings\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Certain types require special case conversion to\r
+            string form. This conversion is done by an object renderer.\r
+            Object renderers implement the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>\r
+            interface.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.IObjectRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">\r
+            <summary>\r
+            Render the object <paramref name="obj"/> to a string\r
+            </summary>\r
+            <param name="rendererMap">The map used to lookup renderers</param>\r
+            <param name="obj">The object to render</param>\r
+            <param name="writer">The writer to render to</param>\r
+            <remarks>\r
+            <para>\r
+            Render the object <paramref name="obj"/> to a \r
+            string.\r
+            </para>\r
+            <para>\r
+            The <paramref name="rendererMap"/> parameter is\r
+            provided to lookup and render other objects. This is\r
+            very useful where <paramref name="obj"/> contains\r
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object, TextWriter)"/>\r
+            method can be used to render these objects.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderObject(log4net.ObjectRenderer.RendererMap,System.Object,System.IO.TextWriter)">\r
+            <summary>\r
+            Render the object <paramref name="obj"/> to a string\r
+            </summary>\r
+            <param name="rendererMap">The map used to lookup renderers</param>\r
+            <param name="obj">The object to render</param>\r
+            <param name="writer">The writer to render to</param>\r
+            <remarks>\r
+            <para>\r
+            Render the object <paramref name="obj"/> to a string.\r
+            </para>\r
+            <para>\r
+            The <paramref name="rendererMap"/> parameter is\r
+            provided to lookup and render other objects. This is\r
+            very useful where <paramref name="obj"/> contains\r
+            nested objects of unknown type. The <see cref="M:RendererMap.FindAndRender(object)"/>\r
+            method can be used to render these objects.\r
+            </para>\r
+            <para>\r
+            The default renderer supports rendering objects to strings as follows:\r
+            </para>\r
+            <list type="table">\r
+               <listheader>\r
+                       <term>Value</term>\r
+                       <description>Rendered String</description>\r
+               </listheader>\r
+               <item>\r
+                       <term><c>null</c></term>\r
+                       <description>\r
+                       <para>"(null)"</para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term><see cref="T:System.Array"/></term>\r
+                       <description>\r
+                       <para>\r
+                       For a one dimensional array this is the\r
+                       array type name, an open brace, followed by a comma\r
+                       separated list of the elements (using the appropriate\r
+                       renderer), followed by a close brace. \r
+                       </para>\r
+                       <para>\r
+                       For example: <c>int[] {1, 2, 3}</c>.\r
+                       </para>\r
+                       <para>\r
+                       If the array is not one dimensional the \r
+                       <c>Array.ToString()</c> is returned.\r
+                       </para>\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term><see cref="T:System.Collections.IEnumerable"/>, <see cref="T:System.Collections.ICollection"/> &amp; <see cref="T:System.Collections.IEnumerator"/></term>\r
+                       <description>\r
+                       <para>\r
+                       Rendered as an open brace, followed by a comma\r
+                       separated list of the elements (using the appropriate\r
+                       renderer), followed by a close brace.\r
+                       </para>\r
+                       <para>\r
+                       For example: <c>{a, b, c}</c>.\r
+                       </para>\r
+                       <para>\r
+                       All collection classes that implement <see cref="T:System.Collections.ICollection"/> its subclasses, \r
+                       or generic equivalents all implement the <see cref="T:System.Collections.IEnumerable"/> interface.\r
+                       </para>\r
+                       </description>\r
+               </item>         \r
+               <item>\r
+                       <term><see cref="T:System.Collections.DictionaryEntry"/></term>\r
+                       <description>\r
+                       <para>\r
+                       Rendered as the key, an equals sign ('='), and the value (using the appropriate\r
+                       renderer). \r
+                       </para>\r
+                       <para>\r
+                       For example: <c>key=value</c>.\r
+                       </para>\r
+                       </description>\r
+               </item>         \r
+               <item>\r
+                       <term>other</term>\r
+                       <description>\r
+                       <para><c>Object.ToString()</c></para>\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderArray(log4net.ObjectRenderer.RendererMap,System.Array,System.IO.TextWriter)">\r
+            <summary>\r
+            Render the array argument into a string\r
+            </summary>\r
+            <param name="rendererMap">The map used to lookup renderers</param>\r
+            <param name="array">the array to render</param>\r
+            <param name="writer">The writer to render to</param>\r
+            <remarks>\r
+            <para>\r
+            For a one dimensional array this is the\r
+            array type name, an open brace, followed by a comma\r
+            separated list of the elements (using the appropriate\r
+            renderer), followed by a close brace. For example:\r
+            <c>int[] {1, 2, 3}</c>.\r
+            </para>\r
+            <para>\r
+            If the array is not one dimensional the \r
+            <c>Array.ToString()</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderEnumerator(log4net.ObjectRenderer.RendererMap,System.Collections.IEnumerator,System.IO.TextWriter)">\r
+            <summary>\r
+            Render the enumerator argument into a string\r
+            </summary>\r
+            <param name="rendererMap">The map used to lookup renderers</param>\r
+            <param name="enumerator">the enumerator to render</param>\r
+            <param name="writer">The writer to render to</param>\r
+            <remarks>\r
+            <para>\r
+            Rendered as an open brace, followed by a comma\r
+            separated list of the elements (using the appropriate\r
+            renderer), followed by a close brace. For example:\r
+            <c>{a, b, c}</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.DefaultRenderer.RenderDictionaryEntry(log4net.ObjectRenderer.RendererMap,System.Collections.DictionaryEntry,System.IO.TextWriter)">\r
+            <summary>\r
+            Render the DictionaryEntry argument into a string\r
+            </summary>\r
+            <param name="rendererMap">The map used to lookup renderers</param>\r
+            <param name="entry">the DictionaryEntry to render</param>\r
+            <param name="writer">The writer to render to</param>\r
+            <remarks>\r
+            <para>\r
+            Render the key, an equals sign ('='), and the value (using the appropriate\r
+            renderer). For example: <c>key=value</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.ObjectRenderer.RendererMap">\r
+            <summary>\r
+            Map class objects to an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Maintains a mapping between types that require special\r
+            rendering and the <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> that\r
+            is used to render them.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:FindAndRender(object)"/> method is used to render an\r
+            <c>object</c> using the appropriate renderers defined in this map.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.#ctor">\r
+            <summary>\r
+            Default Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object)">\r
+            <summary>\r
+            Render <paramref name="obj"/> using the appropriate renderer.\r
+            </summary>\r
+            <param name="obj">the object to render to a string</param>\r
+            <returns>the object rendered as a string</returns>\r
+            <remarks>\r
+            <para>\r
+            This is a convenience method used to render an object to a string.\r
+            The alternative method <see cref="M:FindAndRender(object,TextWriter)"/>\r
+            should be used when streaming output to a <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.FindAndRender(System.Object,System.IO.TextWriter)">\r
+            <summary>\r
+            Render <paramref name="obj"/> using the appropriate renderer.\r
+            </summary>\r
+            <param name="obj">the object to render to a string</param>\r
+            <param name="writer">The writer to render to</param>\r
+            <remarks>\r
+            <para>\r
+            Find the appropriate renderer for the type of the\r
+            <paramref name="obj"/> parameter. This is accomplished by calling the\r
+            <see cref="M:Get(Type)"/> method. Once a renderer is found, it is\r
+            applied on the object <paramref name="obj"/> and the result is returned\r
+            as a <see cref="T:System.String"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Object)">\r
+            <summary>\r
+            Gets the renderer for the specified object type\r
+            </summary>\r
+            <param name="obj">the object to lookup the renderer for</param>\r
+            <returns>the renderer for <paramref name="obj"/></returns>\r
+            <remarks>\r
+            <param>\r
+            Gets the renderer for the specified object type.\r
+            </param>\r
+            <param>\r
+            Syntactic sugar method that calls <see cref="M:Get(Type)"/> \r
+            with the type of the object parameter.\r
+            </param>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.Get(System.Type)">\r
+            <summary>\r
+            Gets the renderer for the specified type\r
+            </summary>\r
+            <param name="type">the type to lookup the renderer for</param>\r
+            <returns>the renderer for the specified type</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the renderer for the specified type.\r
+            If no specific renderer has been defined the\r
+            <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/> will be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.SearchTypeAndInterfaces(System.Type)">\r
+            <summary>\r
+            Internal function to recursively search interfaces\r
+            </summary>\r
+            <param name="type">the type to lookup the renderer for</param>\r
+            <returns>the renderer for the specified type</returns>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.Clear">\r
+            <summary>\r
+            Clear the map of renderers\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clear the custom renderers defined by using\r
+            <see cref="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)"/>. The <see cref="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer"/>\r
+            cannot be removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.ObjectRenderer.RendererMap.Put(System.Type,log4net.ObjectRenderer.IObjectRenderer)">\r
+            <summary>\r
+            Register an <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> for <paramref name="typeToRender"/>. \r
+            </summary>\r
+            <param name="typeToRender">the type that will be rendered by <paramref name="renderer"/></param>\r
+            <param name="renderer">the renderer for <paramref name="typeToRender"/></param>\r
+            <remarks>\r
+            <para>\r
+            Register an object renderer for a specific source type.\r
+            This renderer will be returned from a call to <see cref="M:Get(Type)"/>\r
+            specifying the same <paramref name="typeToRender"/> as an argument.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.ObjectRenderer.RendererMap.DefaultRenderer">\r
+            <summary>\r
+            Get the default renderer instance\r
+            </summary>\r
+            <value>the default renderer</value>\r
+            <remarks>\r
+            <para>\r
+            Get the default renderer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Plugin.IPlugin">\r
+            <summary>\r
+            Interface implemented by logger repository plugins.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Plugins define additional behavior that can be associated\r
+            with a <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            The <see cref="T:log4net.Plugin.PluginMap"/> held by the <see cref="P:log4net.Repository.ILoggerRepository.PluginMap"/>\r
+            property is used to store the plugins for a repository.\r
+            </para>\r
+            <para>\r
+            The <c>log4net.Config.PluginAttribute</c> can be used to\r
+            attach plugins to repositories created using configuration\r
+            attributes.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Plugin.IPlugin.Attach(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Attaches the plugin to the specified <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </summary>\r
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>\r
+            <remarks>\r
+            <para>\r
+            A plugin may only be attached to a single repository.\r
+            </para>\r
+            <para>\r
+            This method is called when the plugin is attached to the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.IPlugin.Shutdown">\r
+            <summary>\r
+            Is called when the plugin is to shutdown.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method is called to notify the plugin that \r
+            it should stop operating and should detach from\r
+            the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Plugin.IPlugin.Name">\r
+            <summary>\r
+            Gets the name of the plugin.\r
+            </summary>\r
+            <value>\r
+            The name of the plugin.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>\r
+            keyed by name. Each plugin instance attached to a\r
+            repository must be a unique name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginCollection">\r
+            <summary>\r
+            A strongly-typed collection of <see cref="T:log4net.Plugin.IPlugin"/> objects.\r
+            </summary>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.ReadOnly(log4net.Plugin.PluginCollection)">\r
+            <summary>\r
+            Creates a read-only wrapper for a <c>PluginCollection</c> instance.\r
+            </summary>\r
+            <param name="list">list to create a readonly wrapper arround</param>\r
+            <returns>\r
+            A <c>PluginCollection</c> wrapper that is read-only.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <c>PluginCollection</c> class\r
+            that is empty and has the default initial capacity.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Int32)">\r
+            <summary>\r
+            Initializes a new instance of the <c>PluginCollection</c> class\r
+            that has the specified initial capacity.\r
+            </summary>\r
+            <param name="capacity">\r
+            The number of elements that the new <c>PluginCollection</c> is initially capable of storing.\r
+            </param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>PluginCollection</c> class\r
+            that contains elements copied from the specified <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="c">The <c>PluginCollection</c> whose elements are copied to the new collection.</param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.IPlugin[])">\r
+            <summary>\r
+            Initializes a new instance of the <c>PluginCollection</c> class\r
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> array.\r
+            </summary>\r
+            <param name="a">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements are copied to the new list.</param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(System.Collections.ICollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>PluginCollection</c> class\r
+            that contains elements copied from the specified <see cref="T:log4net.Plugin.IPlugin"/> collection.\r
+            </summary>\r
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements are copied to the new list.</param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.#ctor(log4net.Plugin.PluginCollection.Tag)">\r
+            <summary>\r
+            Allow subclasses to avoid our default constructors\r
+            </summary>\r
+            <param name="tag"></param>\r
+            <exclude/>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[])">\r
+            <summary>\r
+            Copies the entire <c>PluginCollection</c> to a one-dimensional\r
+            <see cref="T:log4net.Plugin.IPlugin"/> array.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.CopyTo(log4net.Plugin.IPlugin[],System.Int32)">\r
+            <summary>\r
+            Copies the entire <c>PluginCollection</c> to a one-dimensional\r
+            <see cref="T:log4net.Plugin.IPlugin"/> array, starting at the specified index of the target array.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:log4net.Plugin.IPlugin"/> array to copy to.</param>\r
+            <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Add(log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the end of the <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to be added to the end of the <c>PluginCollection</c>.</param>\r
+            <returns>The index at which the value has been added.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Clear">\r
+            <summary>\r
+            Removes all elements from the <c>PluginCollection</c>.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Clone">\r
+            <summary>\r
+            Creates a shallow copy of the <see cref="T:log4net.Plugin.PluginCollection"/>.\r
+            </summary>\r
+            <returns>A new <see cref="T:log4net.Plugin.PluginCollection"/> with a shallow copy of the collection data.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Contains(log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Determines whether a given <see cref="T:log4net.Plugin.IPlugin"/> is in the <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to check for.</param>\r
+            <returns><c>true</c> if <paramref name="item"/> is found in the <c>PluginCollection</c>; otherwise, <c>false</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.IndexOf(log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Returns the zero-based index of the first occurrence of a <see cref="T:log4net.Plugin.IPlugin"/>\r
+            in the <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to locate in the <c>PluginCollection</c>.</param>\r
+            <returns>\r
+            The zero-based index of the first occurrence of <paramref name="item"/> \r
+            in the entire <c>PluginCollection</c>, if found; otherwise, -1.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Insert(System.Int32,log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Inserts an element into the <c>PluginCollection</c> at the specified index.\r
+            </summary>\r
+            <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>\r
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to insert.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Remove(log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Removes the first occurrence of a specific <see cref="T:log4net.Plugin.IPlugin"/> from the <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="item">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the <c>PluginCollection</c>.</param>\r
+            <exception cref="T:System.ArgumentException">\r
+            The specified <see cref="T:log4net.Plugin.IPlugin"/> was not found in the <c>PluginCollection</c>.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.RemoveAt(System.Int32)">\r
+            <summary>\r
+            Removes the element at the specified index of the <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="index">The zero-based index of the element to remove.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.GetEnumerator">\r
+            <summary>\r
+            Returns an enumerator that can iterate through the <c>PluginCollection</c>.\r
+            </summary>\r
+            <returns>An <see cref="T:log4net.Plugin.PluginCollection.Enumerator"/> for the entire <c>PluginCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.PluginCollection)">\r
+            <summary>\r
+            Adds the elements of another <c>PluginCollection</c> to the current <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="x">The <c>PluginCollection</c> whose elements should be added to the end of the current <c>PluginCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(log4net.Plugin.IPlugin[])">\r
+            <summary>\r
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> array to the current <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="x">The <see cref="T:log4net.Plugin.IPlugin"/> array whose elements should be added to the end of the <c>PluginCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.AddRange(System.Collections.ICollection)">\r
+            <summary>\r
+            Adds the elements of a <see cref="T:log4net.Plugin.IPlugin"/> collection to the current <c>PluginCollection</c>.\r
+            </summary>\r
+            <param name="col">The <see cref="T:log4net.Plugin.IPlugin"/> collection whose elements should be added to the end of the <c>PluginCollection</c>.</param>\r
+            <returns>The new <see cref="P:log4net.Plugin.PluginCollection.Count"/> of the <c>PluginCollection</c>.</returns>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.TrimToSize">\r
+            <summary>\r
+            Sets the capacity to the actual number of elements.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32)">\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="i"/> is less than zero.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.ValidateIndex(System.Int32,System.Boolean)">\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="i"/> is less than zero.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="i"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.Count">\r
+            <summary>\r
+            Gets the number of elements actually contained in the <c>PluginCollection</c>.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.IsSynchronized">\r
+            <summary>\r
+            Gets a value indicating whether access to the collection is synchronized (thread-safe).\r
+            </summary>\r
+            <returns>true if access to the ICollection is synchronized (thread-safe); otherwise, false.</returns>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.SyncRoot">\r
+            <summary>\r
+            Gets an object that can be used to synchronize access to the collection.\r
+            </summary>\r
+            <value>\r
+            An object that can be used to synchronize access to the collection.\r
+            </value>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.Item(System.Int32)">\r
+            <summary>\r
+            Gets or sets the <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Plugin.IPlugin"/> at the specified index.\r
+            </value>\r
+            <param name="index">The zero-based index of the element to get or set.</param>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">\r
+            <para><paramref name="index"/> is less than zero.</para>\r
+            <para>-or-</para>\r
+            <para><paramref name="index"/> is equal to or greater than <see cref="P:log4net.Plugin.PluginCollection.Count"/>.</para>\r
+            </exception>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.IsFixedSize">\r
+            <summary>\r
+            Gets a value indicating whether the collection has a fixed size.\r
+            </summary>\r
+            <value><c>true</c> if the collection has a fixed size; otherwise, <c>false</c>. The default is <c>false</c>.</value>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.IsReadOnly">\r
+            <summary>\r
+            Gets a value indicating whether the IList is read-only.\r
+            </summary>\r
+            <value><c>true</c> if the collection is read-only; otherwise, <c>false</c>. The default is <c>false</c>.</value>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.Capacity">\r
+            <summary>\r
+            Gets or sets the number of elements the <c>PluginCollection</c> can contain.\r
+            </summary>\r
+            <value>\r
+            The number of elements the <c>PluginCollection</c> can contain.\r
+            </value>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator">\r
+            <summary>\r
+            Supports type-safe iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.\r
+            </summary>\r
+            <exclude/>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.MoveNext">\r
+            <summary>\r
+            Advances the enumerator to the next element in the collection.\r
+            </summary>\r
+            <returns>\r
+            <c>true</c> if the enumerator was successfully advanced to the next element; \r
+            <c>false</c> if the enumerator has passed the end of the collection.\r
+            </returns>\r
+            <exception cref="T:System.InvalidOperationException">\r
+            The collection was modified after the enumerator was created.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Reset">\r
+            <summary>\r
+            Sets the enumerator to its initial position, before the first element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.IPluginCollectionEnumerator.Current">\r
+            <summary>\r
+            Gets the current element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginCollection.Tag">\r
+            <summary>\r
+            Type visible only to our subclasses\r
+            Used to access protected constructor\r
+            </summary>\r
+            <exclude/>\r
+        </member>\r
+        <member name="F:log4net.Plugin.PluginCollection.Tag.Default">\r
+            <summary>\r
+            A value\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginCollection.Enumerator">\r
+            <summary>\r
+            Supports simple iteration over a <see cref="T:log4net.Plugin.PluginCollection"/>.\r
+            </summary>\r
+            <exclude/>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.#ctor(log4net.Plugin.PluginCollection)">\r
+            <summary>\r
+            Initializes a new instance of the <c>Enumerator</c> class.\r
+            </summary>\r
+            <param name="tc"></param>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.MoveNext">\r
+            <summary>\r
+            Advances the enumerator to the next element in the collection.\r
+            </summary>\r
+            <returns>\r
+            <c>true</c> if the enumerator was successfully advanced to the next element; \r
+            <c>false</c> if the enumerator has passed the end of the collection.\r
+            </returns>\r
+            <exception cref="T:System.InvalidOperationException">\r
+            The collection was modified after the enumerator was created.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginCollection.Enumerator.Reset">\r
+            <summary>\r
+            Sets the enumerator to its initial position, before the first element in the collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginCollection.Enumerator.Current">\r
+            <summary>\r
+            Gets the current element in the collection.\r
+            </summary>\r
+            <value>\r
+            The current element in the collection.\r
+            </value>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginCollection.ReadOnlyPluginCollection">\r
+            <exclude/>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginMap">\r
+            <summary>\r
+            Map of repository plugins.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class is a name keyed map of the plugins that are\r
+            attached to a repository.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginMap.#ctor(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="repository">The repository that the plugins should be attached to.</param>\r
+            <remarks>\r
+            <para>\r
+            Initialize a new instance of the <see cref="T:log4net.Plugin.PluginMap"/> class with a \r
+            repository that the plugins should be attached to.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginMap.Add(log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Adds a <see cref="T:log4net.Plugin.IPlugin"/> to the map.\r
+            </summary>\r
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to add to the map.</param>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Plugin.IPlugin"/> will be attached to the repository when added.\r
+            </para>\r
+            <para>\r
+            If there already exists a plugin with the same name \r
+            attached to the repository then the old plugin will\r
+            be <see cref="M:log4net.Plugin.IPlugin.Shutdown"/> and replaced with\r
+            the new plugin.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginMap.Remove(log4net.Plugin.IPlugin)">\r
+            <summary>\r
+            Removes a <see cref="T:log4net.Plugin.IPlugin"/> from the map.\r
+            </summary>\r
+            <param name="plugin">The <see cref="T:log4net.Plugin.IPlugin"/> to remove from the map.</param>\r
+            <remarks>\r
+            <para>\r
+            Remove a specific plugin from this map.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginMap.Item(System.String)">\r
+            <summary>\r
+            Gets a <see cref="T:log4net.Plugin.IPlugin"/> by name.\r
+            </summary>\r
+            <param name="name">The name of the <see cref="T:log4net.Plugin.IPlugin"/> to lookup.</param>\r
+            <returns>\r
+            The <see cref="T:log4net.Plugin.IPlugin"/> from the map with the name specified, or \r
+            <c>null</c> if no plugin is found.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Lookup a plugin by name. If the plugin is not found <c>null</c>\r
+            will be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginMap.AllPlugins">\r
+            <summary>\r
+            Gets all possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.\r
+            </summary>\r
+            <value>All possible plugins as a list of <see cref="T:log4net.Plugin.IPlugin"/> objects.</value>\r
+            <remarks>\r
+            <para>\r
+            Get a collection of all the plugins defined in this map.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Plugin.PluginSkeleton">\r
+            <summary>\r
+            Base implementation of <see cref="T:log4net.Plugin.IPlugin"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default abstract implementation of the <see cref="T:log4net.Plugin.IPlugin"/>\r
+            interface. This base class can be used by implementors\r
+            of the <see cref="T:log4net.Plugin.IPlugin"/> interface.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginSkeleton.#ctor(System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="name">the name of the plugin</param>\r
+            <remarks>\r
+            Initializes a new Plugin with the specified name.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginSkeleton.Attach(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </summary>\r
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>\r
+            <remarks>\r
+            <para>\r
+            A plugin may only be attached to a single repository.\r
+            </para>\r
+            <para>\r
+            This method is called when the plugin is attached to the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.PluginSkeleton.Shutdown">\r
+            <summary>\r
+            Is called when the plugin is to shutdown.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method is called to notify the plugin that \r
+            it should stop operating and should detach from\r
+            the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Plugin.PluginSkeleton.m_name">\r
+            <summary>\r
+            The name of this plugin.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Plugin.PluginSkeleton.m_repository">\r
+            <summary>\r
+            The repository this plugin is attached to.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginSkeleton.Name">\r
+            <summary>\r
+            Gets or sets the name of the plugin.\r
+            </summary>\r
+            <value>\r
+            The name of the plugin.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Plugins are stored in the <see cref="T:log4net.Plugin.PluginMap"/>\r
+            keyed by name. Each plugin instance attached to a\r
+            repository must be a unique name.\r
+            </para>\r
+            <para>\r
+            The name of the plugin must not change one the \r
+            plugin has been attached to a repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Plugin.PluginSkeleton.LoggerRepository">\r
+            <summary>\r
+            The repository for this plugin\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is attached to.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin is \r
+            attached to.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin">\r
+            <summary>\r
+            Plugin that listens for events from the <see cref="T:log4net.Appender.RemotingAppender"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This plugin publishes an instance of <see cref="T:log4net.Appender.RemotingAppender.IRemoteLoggingSink"/> \r
+            on a specified <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/>. This listens for logging events delivered from\r
+            a remote <see cref="T:log4net.Appender.RemotingAppender"/>.\r
+            </para>\r
+            <para>\r
+            When an event is received it is relogged within the attached repository\r
+            as if it had been raised locally.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class.\r
+            </para>\r
+            <para>\r
+            The <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> property must be set.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.#ctor(System.String)">\r
+            <summary>\r
+            Construct with sink Uri.\r
+            </summary>\r
+            <param name="sinkUri">The name to publish the sink under in the remoting infrastructure. \r
+            See <see cref="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri"/> for more details.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin"/> class\r
+            with specified name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Attach(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Attaches this plugin to a <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </summary>\r
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that this plugin should be attached to.</param>\r
+            <remarks>\r
+            <para>\r
+            A plugin may only be attached to a single repository.\r
+            </para>\r
+            <para>\r
+            This method is called when the plugin is attached to the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.Shutdown">\r
+            <summary>\r
+            Is called when the plugin is to shutdown.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            When the plugin is shutdown the remote logging\r
+            sink is disconnected.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.declaringType">\r
+            <summary>\r
+            The fully qualified type of the RemoteLoggingServerPlugin class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Plugin.RemoteLoggingServerPlugin.SinkUri">\r
+            <summary>\r
+            Gets or sets the URI of this sink.\r
+            </summary>\r
+            <value>\r
+            The URI of this sink.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This is the name under which the object is marshaled.\r
+            <see cref="M:RemotingServices.Marshal(MarshalByRefObject,String,Type)"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl">\r
+            <summary>\r
+            Delivers <see cref="T:log4net.Core.LoggingEvent"/> objects to a remote sink.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Internal class used to listen for logging events\r
+            and deliver them to the local repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.#ctor(log4net.Repository.ILoggerRepository)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="repository">The repository to log to.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl"/> for the\r
+            specified <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.LogEvents(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Logs the events to the repository.\r
+            </summary>\r
+            <param name="events">The events to log.</param>\r
+            <remarks>\r
+            <para>\r
+            The events passed are logged to the <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.InitializeLifetimeService">\r
+            <summary>\r
+            Obtains a lifetime service object to control the lifetime \r
+            policy for this instance.\r
+            </summary>\r
+            <returns><c>null</c> to indicate that this instance should live forever.</returns>\r
+            <remarks>\r
+            <para>\r
+            Obtains a lifetime service object to control the lifetime \r
+            policy for this instance. This object should live forever\r
+            therefore this implementation returns <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Plugin.RemoteLoggingServerPlugin.RemoteLoggingSinkImpl.m_repository">\r
+            <summary>\r
+            The underlying <see cref="T:log4net.Repository.ILoggerRepository"/> that events should\r
+            be logged to.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory">\r
+            <summary>\r
+            Default implementation of <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This default implementation of the <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>\r
+            interface is used to create the default subclass\r
+            of the <see cref="T:log4net.Repository.Hierarchy.Logger"/> object.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.ILoggerFactory">\r
+            <summary>\r
+            Interface abstracts creation of <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This interface is used by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to \r
+            create new <see cref="T:log4net.Repository.Hierarchy.Logger"/> objects.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)"/> method is called\r
+            to create a named <see cref="T:log4net.Repository.Hierarchy.Logger"/>.\r
+            </para>\r
+            <para>\r
+            Implement this interface to create new subclasses of <see cref="T:log4net.Repository.Hierarchy.Logger"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.ILoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">\r
+            <summary>\r
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance\r
+            </summary>\r
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>\r
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>\r
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>\r
+            <remarks>\r
+            <para>\r
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the \r
+            specified name.\r
+            </para>\r
+            <para>\r
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create\r
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.\r
+            </para>\r
+            <para>\r
+            If the <paramref name="name"/> is <c>null</c> then the root logger\r
+            must be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> class. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.CreateLogger(log4net.Repository.ILoggerRepository,System.String)">\r
+            <summary>\r
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance\r
+            </summary>\r
+            <param name="repository">The <see cref="T:log4net.Repository.ILoggerRepository"/> that will own the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>\r
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>\r
+            <returns>The <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance for the specified name.</returns>\r
+            <remarks>\r
+            <para>\r
+            Create a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance with the \r
+            specified name.\r
+            </para>\r
+            <para>\r
+            Called by the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> to create\r
+            new named <see cref="T:log4net.Repository.Hierarchy.Logger"/> instances.\r
+            </para>\r
+            <para>\r
+            If the <paramref name="name"/> is <c>null</c> then the root logger\r
+            must be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl">\r
+            <summary>\r
+            Default internal subclass of <see cref="T:log4net.Repository.Hierarchy.Logger"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This subclass has no additional behavior over the\r
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> class but does allow instances\r
+            to be created.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.Logger">\r
+            <summary>\r
+            Implementation of <see cref="T:log4net.Core.ILogger"/> used by <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Internal class used to provide implementation of <see cref="T:log4net.Core.ILogger"/>\r
+            interface. Applications should use <see cref="T:log4net.LogManager"/> to get\r
+            logger instances.\r
+            </para>\r
+            <para>\r
+            This is one of the central classes in the log4net implementation. One of the\r
+            distinctive features of log4net are hierarchical loggers and their\r
+            evaluation. The <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> organizes the <see cref="T:log4net.Repository.Hierarchy.Logger"/>\r
+            instances into a rooted tree hierarchy.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.Hierarchy.Logger"/> class is abstract. Only concrete subclasses of\r
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> can be created. The <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>\r
+            is used to create instances of this type for the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Aspi Havewala</author>\r
+            <author>Douglas de la Torre</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.#ctor(System.String)">\r
+            <summary>\r
+            This constructor created a new <see cref="T:log4net.Repository.Hierarchy.Logger"/> instance and\r
+            sets its name.\r
+            </summary>\r
+            <param name="name">The name of the <see cref="T:log4net.Repository.Hierarchy.Logger"/>.</param>\r
+            <remarks>\r
+            <para>\r
+            This constructor is protected and designed to be used by\r
+            a subclass that is not abstract.\r
+            </para>\r
+            <para>\r
+            Loggers are constructed by <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> \r
+            objects. See <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory"/> for the default\r
+            logger creator.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.AddAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Add <paramref name="newAppender"/> to the list of appenders of this\r
+            Logger instance.\r
+            </summary>\r
+            <param name="newAppender">An appender to add to this logger</param>\r
+            <remarks>\r
+            <para>\r
+            Add <paramref name="newAppender"/> to the list of appenders of this\r
+            Logger instance.\r
+            </para>\r
+            <para>\r
+            If <paramref name="newAppender"/> is already in the list of\r
+            appenders, then it won't be added again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.GetAppender(System.String)">\r
+            <summary>\r
+            Look for the appender named as <c>name</c>\r
+            </summary>\r
+            <param name="name">The name of the appender to lookup</param>\r
+            <returns>The appender with the name specified, or <c>null</c>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the named appender, or null if the appender is not found.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAllAppenders">\r
+            <summary>\r
+            Remove all previously added appenders from this Logger instance.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Remove all previously added appenders from this Logger instance.\r
+            </para>\r
+            <para>\r
+            This is useful when re-reading configuration information.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Remove the appender passed as parameter form the list of appenders.\r
+            </summary>\r
+            <param name="appender">The appender to remove</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            <para>\r
+            Remove the appender passed as parameter form the list of appenders.\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.RemoveAppender(System.String)">\r
+            <summary>\r
+            Remove the appender passed as parameter form the list of appenders.\r
+            </summary>\r
+            <param name="name">The name of the appender to remove</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            <para>\r
+            Remove the named appender passed as parameter form the list of appenders.\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(System.Type,log4net.Core.Level,System.Object,System.Exception)">\r
+            <summary>\r
+            This generic form is intended to be used by wrappers.\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <param name="level">The level of the message to be logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Generate a logging event for the specified <paramref name="level"/> using\r
+            the <paramref name="message"/> and <paramref name="exception"/>.\r
+            </para>\r
+            <para>\r
+            This method must not throw any exception to the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            This is the most generic printing method that is intended to be used \r
+            by wrappers.\r
+            </summary>\r
+            <param name="logEvent">The event being logged.</param>\r
+            <remarks>\r
+            <para>\r
+            Logs the specified logging event through this logger.\r
+            </para>\r
+            <para>\r
+            This method must not throw any exception to the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.IsEnabledFor(log4net.Core.Level)">\r
+            <summary>\r
+            Checks if this logger is enabled for a given <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> passed as parameter.\r
+            </summary>\r
+            <param name="level">The level to check.</param>\r
+            <returns>\r
+            <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Test if this logger is going to log events of the specified <paramref name="level"/>.\r
+            </para>\r
+            <para>\r
+            This method must not throw any exception to the caller.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.CallAppenders(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Deliver the <see cref="T:log4net.Core.LoggingEvent"/> to the attached appenders.\r
+            </summary>\r
+            <param name="loggingEvent">The event to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Call the appenders in the hierarchy starting at\r
+            <c>this</c>. If no appenders could be found, emit a\r
+            warning.\r
+            </para>\r
+            <para>\r
+            This method calls all the appenders inherited from the\r
+            hierarchy circumventing any evaluation of whether to log or not\r
+            to log the particular log request.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.CloseNestedAppenders">\r
+            <summary>\r
+            Closes all attached appenders implementing the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Used to ensure that the appenders are correctly shutdown.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.Log(log4net.Core.Level,System.Object,System.Exception)">\r
+            <summary>\r
+            This is the most generic printing method. This generic form is intended to be used by wrappers\r
+            </summary>\r
+            <param name="level">The level of the message to be logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Generate a logging event for the specified <paramref name="level"/> using\r
+            the <paramref name="message"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(System.Type,log4net.Core.Level,System.Object,System.Exception)">\r
+            <summary>\r
+            Creates a new logging event and logs the event without further checks.\r
+            </summary>\r
+            <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is\r
+            the stack boundary into the logging system for this call.</param>\r
+            <param name="level">The level of the message to be logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            Generates a logging event and delivers it to the attached\r
+            appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Logger.ForcedLog(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Creates a new logging event and logs the event without further checks.\r
+            </summary>\r
+            <param name="logEvent">The event being logged.</param>\r
+            <remarks>\r
+            <para>\r
+            Delivers the logging event to the attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.declaringType">\r
+            <summary>\r
+            The fully qualified type of the Logger class.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_name">\r
+            <summary>\r
+            The name of this logger.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_level">\r
+            <summary>\r
+            The assigned level of this logger. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>level</c> variable need not be \r
+            assigned a value in which case it is inherited \r
+            form the hierarchy.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_parent">\r
+            <summary>\r
+            The parent of this logger.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The parent of this logger. \r
+            All loggers have at least one ancestor which is the root logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_hierarchy">\r
+            <summary>\r
+            Loggers need to know what Hierarchy they are in.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Loggers need to know what Hierarchy they are in.\r
+            The hierarchy that this logger is a member of is stored\r
+            here.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderAttachedImpl">\r
+            <summary>\r
+            Helper implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_additive">\r
+            <summary>\r
+            Flag indicating if child loggers inherit their parents appenders\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Additivity is set to true by default, that is children inherit\r
+            the appenders of their ancestors by default. If this variable is\r
+            set to <c>false</c> then the appenders found in the\r
+            ancestors of this logger are not used. However, the children\r
+            of this logger will inherit its appenders, unless the children\r
+            have their additivity flag set to <c>false</c> too. See\r
+            the user manual for more details.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Logger.m_appenderLock">\r
+            <summary>\r
+            Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Parent">\r
+            <summary>\r
+            Gets or sets the parent logger in the hierarchy.\r
+            </summary>\r
+            <value>\r
+            The parent logger in the hierarchy.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Part of the Composite pattern that makes the hierarchy.\r
+            The hierarchy is parent linked rather than child linked.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Additivity">\r
+            <summary>\r
+            Gets or sets a value indicating if child loggers inherit their parent's appenders.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if child loggers inherit their parent's appenders.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Additivity is set to <c>true</c> by default, that is children inherit\r
+            the appenders of their ancestors by default. If this variable is\r
+            set to <c>false</c> then the appenders found in the\r
+            ancestors of this logger are not used. However, the children\r
+            of this logger will inherit its appenders, unless the children\r
+            have their additivity flag set to <c>false</c> too. See\r
+            the user manual for more details.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.EffectiveLevel">\r
+            <summary>\r
+            Gets the effective level for this logger.\r
+            </summary>\r
+            <returns>The nearest level in the logger hierarchy.</returns>\r
+            <remarks>\r
+            <para>\r
+            Starting from this logger, searches the logger hierarchy for a\r
+            non-null level and returns it. Otherwise, returns the level of the\r
+            root logger.\r
+            </para>\r
+            <para>The Logger class is designed so that this method executes as\r
+            quickly as possible.</para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Hierarchy">\r
+            <summary>\r
+            Gets or sets the <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/> where this \r
+            <c>Logger</c> instance is attached to.\r
+            </summary>\r
+            <value>The hierarchy that this logger belongs to.</value>\r
+            <remarks>\r
+            <para>\r
+            This logger must be attached to a single <see cref="P:log4net.Repository.Hierarchy.Logger.Hierarchy"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Level">\r
+            <summary>\r
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>, if any, for this Logger.  \r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> of this logger.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The assigned <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/> can be <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Appenders">\r
+            <summary>\r
+            Get the appenders contained in this logger as an \r
+            <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <returns>A collection of the appenders in this logger</returns>\r
+            <remarks>\r
+            <para>\r
+            Get the appenders contained in this logger as an \r
+            <see cref="T:System.Collections.ICollection"/>. If no appenders \r
+            can be found, then a <see cref="T:log4net.Util.EmptyCollection"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Name">\r
+            <summary>\r
+            Gets the logger name.\r
+            </summary>\r
+            <value>\r
+            The name of the logger.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of this logger\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Logger.Repository">\r
+            <summary>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this \r
+            <c>Logger</c> instance is attached to.\r
+            </summary>\r
+            <value>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> that this logger belongs to.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> where this \r
+            <c>Logger</c> instance is attached to.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl.#ctor(System.String)">\r
+            <summary>\r
+            Construct a new Logger\r
+            </summary>\r
+            <param name="name">the name of the logger</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.DefaultLoggerFactory.LoggerImpl"/> class\r
+            with the specified name. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventHandler">\r
+            <summary>\r
+            Delegate used to handle logger creation event notifications.\r
+            </summary>\r
+            <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>\r
+            <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>\r
+            <remarks>\r
+            <para>\r
+            Delegate used to handle logger creation event notifications.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs">\r
+            <summary>\r
+            Provides data for the <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A <see cref="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent"/> event is raised every time a\r
+            <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> is created.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.LoggerCreationEventArgs.m_log">\r
+            <summary>\r
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> created\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.LoggerCreationEventArgs.#ctor(log4net.Repository.Hierarchy.Logger)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="log">The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerCreationEventArgs"/> event argument \r
+            class,with the specified <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger">\r
+            <summary>\r
+            Gets the <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="P:log4net.Repository.Hierarchy.LoggerCreationEventArgs.Logger"/> that has been created.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy">\r
+            <summary>\r
+            Hierarchical organization of loggers\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <i>The casual user should not have to deal with this class\r
+            directly.</i>\r
+            </para>\r
+            <para>\r
+            This class is specialized in retrieving loggers by name and\r
+            also maintaining the logger hierarchy. Implements the \r
+            <see cref="T:log4net.Repository.ILoggerRepository"/> interface.\r
+            </para>\r
+            <para>\r
+            The structure of the logger hierarchy is maintained by the\r
+            <see cref="M:GetLogger(string)"/> method. The hierarchy is such that children\r
+            link to their parent but parents do not have any references to their\r
+            children. Moreover, loggers can be instantiated in any order, in\r
+            particular descendant before ancestor.\r
+            </para>\r
+            <para>\r
+            In case a descendant is created before a particular ancestor,\r
+            then it creates a provision node for the ancestor and adds itself\r
+            to the provision node. Other descendants of the same ancestor add\r
+            themselves to the previously created provision node.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Repository.LoggerRepositorySkeleton">\r
+            <summary>\r
+            Base implementation of <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default abstract implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.\r
+            </para>\r
+            <para>\r
+            Skeleton implementation of the <see cref="T:log4net.Repository.ILoggerRepository"/> interface.\r
+            All <see cref="T:log4net.Repository.ILoggerRepository"/> types can extend this type.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Repository.ILoggerRepository">\r
+            <summary>\r
+            Interface implemented by logger repositories.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This interface is implemented by logger repositories. e.g. \r
+            <see cref="N:log4net.Repository.Hierarchy"/>.\r
+            </para>\r
+            <para>\r
+            This interface is used by the <see cref="T:log4net.LogManager"/>\r
+            to obtain <see cref="T:log4net.ILog"/> interfaces.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.Exists(System.String)">\r
+            <summary>\r
+            Check if the named logger exists in the repository. If so return\r
+            its reference, otherwise returns <c>null</c>.\r
+            </summary>\r
+            <param name="name">The name of the logger to lookup</param>\r
+            <returns>The Logger object with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            If the names logger exists it is returned, otherwise\r
+            <c>null</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.GetCurrentLoggers">\r
+            <summary>\r
+            Returns all the currently defined loggers as an Array.\r
+            </summary>\r
+            <returns>All the defined loggers</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns all the currently defined loggers as an Array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.GetLogger(System.String)">\r
+            <summary>\r
+            Returns a named logger instance\r
+            </summary>\r
+            <param name="name">The name of the logger to retrieve</param>\r
+            <returns>The logger object with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns a named logger instance.\r
+            </para>\r
+            <para>\r
+            If a logger of that name already exists, then it will be\r
+            returned.  Otherwise, a new logger will be instantiated and\r
+            then linked with its existing ancestors as well as children.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.Shutdown">\r
+            <summary>Shutdown the repository</summary>\r
+            <remarks>\r
+            <para>\r
+            Shutting down a repository will <i>safely</i> close and remove\r
+            all appenders in all loggers including the root logger.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the\r
+            application exists. Otherwise, pending logging events might be\r
+            lost.\r
+            </para>\r
+            <para>\r
+            The <see cref="M:Shutdown()"/> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.ResetConfiguration">\r
+            <summary>\r
+            Reset the repositories configuration to a default state\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Reset all values contained in this instance to their\r
+            default state.\r
+            </para>\r
+            <para>\r
+            Existing loggers are not removed. They are just reset.\r
+            </para>\r
+            <para>\r
+            This method should be used sparingly and with care as it will\r
+            block all logging until it is completed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.Log(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Log the <see cref="T:log4net.Core.LoggingEvent"/> through this repository.\r
+            </summary>\r
+            <param name="logEvent">the event to log</param>\r
+            <remarks>\r
+            <para>\r
+            This method should not normally be used to log.\r
+            The <see cref="T:log4net.ILog"/> interface should be used \r
+            for routine logging. This interface can be obtained\r
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.\r
+            </para>\r
+            <para>\r
+            The <c>logEvent</c> is delivered to the appropriate logger and\r
+            that logger is then responsible for logging the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.ILoggerRepository.GetAppenders">\r
+            <summary>\r
+            Returns all the Appenders that are configured as an Array.\r
+            </summary>\r
+            <returns>All the Appenders</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns all the Appenders that are configured as an Array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.Name">\r
+            <summary>\r
+            The name of the repository\r
+            </summary>\r
+            <value>\r
+            The name of the repository\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of the repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.RendererMap">\r
+            <summary>\r
+            RendererMap accesses the object renderer map for this repository.\r
+            </summary>\r
+            <value>\r
+            RendererMap accesses the object renderer map for this repository.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            RendererMap accesses the object renderer map for this repository.\r
+            </para>\r
+            <para>\r
+            The RendererMap holds a mapping between types and\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.PluginMap">\r
+            <summary>\r
+            The plugin map for this repository.\r
+            </summary>\r
+            <value>\r
+            The plugin map for this repository.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances\r
+            that have been attached to this repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.LevelMap">\r
+            <summary>\r
+            Get the level map for the Repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Get the level map for the Repository.\r
+            </para>\r
+            <para>\r
+            The level map defines the mappings between\r
+            level names and <see cref="T:log4net.Core.Level"/> objects in\r
+            this repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.Threshold">\r
+            <summary>\r
+            The threshold for all events in this repository\r
+            </summary>\r
+            <value>\r
+            The threshold for all events in this repository\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The threshold for all events in this repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.Configured">\r
+            <summary>\r
+            Flag indicates if this repository has been configured.\r
+            </summary>\r
+            <value>\r
+            Flag indicates if this repository has been configured.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Flag indicates if this repository has been configured.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.ConfigurationMessages">\r
+            <summary>\r
+            Collection of internal messages captured during the most \r
+            recent configuration process.\r
+            </summary>\r
+        </member>\r
+        <member name="E:log4net.Repository.ILoggerRepository.ShutdownEvent">\r
+            <summary>\r
+            Event to notify that the repository has been shutdown.\r
+            </summary>\r
+            <value>\r
+            Event to notify that the repository has been shutdown.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when the repository has been shutdown.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationReset">\r
+            <summary>\r
+            Event to notify that the repository has had its configuration reset.\r
+            </summary>\r
+            <value>\r
+            Event to notify that the repository has had its configuration reset.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when the repository's configuration has been\r
+            reset to default.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Repository.ILoggerRepository.ConfigurationChanged">\r
+            <summary>\r
+            Event to notify that the repository has had its configuration changed.\r
+            </summary>\r
+            <value>\r
+            Event to notify that the repository has had its configuration changed.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when the repository's configuration has been changed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.ILoggerRepository.Properties">\r
+            <summary>\r
+            Repository specific properties\r
+            </summary>\r
+            <value>\r
+            Repository specific properties\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            These properties can be specified on a repository specific basis.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor">\r
+            <summary>\r
+            Default Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes the repository with default (empty) properties.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.#ctor(log4net.Util.PropertiesDictionary)">\r
+            <summary>\r
+            Construct the repository using specific properties\r
+            </summary>\r
+            <param name="properties">the properties to set for this repository</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes the repository with specified properties.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Exists(System.String)">\r
+            <summary>\r
+            Test if logger exists\r
+            </summary>\r
+            <param name="name">The name of the logger to lookup</param>\r
+            <returns>The Logger object with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Check if the named logger exists in the repository. If so return\r
+            its reference, otherwise returns <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetCurrentLoggers">\r
+            <summary>\r
+            Returns all the currently defined loggers in the repository\r
+            </summary>\r
+            <returns>All the defined loggers</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns all the currently defined loggers in the repository as an Array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetLogger(System.String)">\r
+            <summary>\r
+            Return a new logger instance\r
+            </summary>\r
+            <param name="name">The name of the logger to retrieve</param>\r
+            <returns>The logger object with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Return a new logger instance.\r
+            </para>\r
+            <para>\r
+            If a logger of that name already exists, then it will be\r
+            returned. Otherwise, a new logger will be instantiated and\r
+            then linked with its existing ancestors as well as children.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Shutdown">\r
+            <summary>\r
+            Shutdown the repository\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Shutdown the repository. Can be overridden in a subclass.\r
+            This base class implementation notifies the <see cref="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent"/>\r
+            listeners and all attached plugins of the shutdown event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.ResetConfiguration">\r
+            <summary>\r
+            Reset the repositories configuration to a default state\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Reset all values contained in this instance to their\r
+            default state.\r
+            </para>\r
+            <para>\r
+            Existing loggers are not removed. They are just reset.\r
+            </para>\r
+            <para>\r
+            This method should be used sparingly and with care as it will\r
+            block all logging until it is completed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.Log(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Log the logEvent through this repository.\r
+            </summary>\r
+            <param name="logEvent">the event to log</param>\r
+            <remarks>\r
+            <para>\r
+            This method should not normally be used to log.\r
+            The <see cref="T:log4net.ILog"/> interface should be used \r
+            for routine logging. This interface can be obtained\r
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.\r
+            </para>\r
+            <para>\r
+            The <c>logEvent</c> is delivered to the appropriate logger and\r
+            that logger is then responsible for logging the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.GetAppenders">\r
+            <summary>\r
+            Returns all the Appenders that are configured as an Array.\r
+            </summary>\r
+            <returns>All the Appenders</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns all the Appenders that are configured as an Array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.LoggerRepositorySkeleton.declaringType">\r
+            <summary>\r
+            The fully qualified type of the LoggerRepositorySkeleton class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.AddRenderer(System.Type,log4net.ObjectRenderer.IObjectRenderer)">\r
+            <summary>\r
+            Adds an object renderer for a specific class. \r
+            </summary>\r
+            <param name="typeToRender">The type that will be rendered by the renderer supplied.</param>\r
+            <param name="rendererInstance">The object renderer used to render the object.</param>\r
+            <remarks>\r
+            <para>\r
+            Adds an object renderer for a specific class. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnShutdown(System.EventArgs)">\r
+            <summary>\r
+            Notify the registered listeners that the repository is shutting down\r
+            </summary>\r
+            <param name="e">Empty EventArgs</param>\r
+            <remarks>\r
+            <para>\r
+            Notify any listeners that this repository is shutting down.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationReset(System.EventArgs)">\r
+            <summary>\r
+            Notify the registered listeners that the repository has had its configuration reset\r
+            </summary>\r
+            <param name="e">Empty EventArgs</param>\r
+            <remarks>\r
+            <para>\r
+            Notify any listeners that this repository's configuration has been reset.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.OnConfigurationChanged(System.EventArgs)">\r
+            <summary>\r
+            Notify the registered listeners that the repository has had its configuration changed\r
+            </summary>\r
+            <param name="e">Empty EventArgs</param>\r
+            <remarks>\r
+            <para>\r
+            Notify any listeners that this repository's configuration has changed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.LoggerRepositorySkeleton.RaiseConfigurationChanged(System.EventArgs)">\r
+            <summary>\r
+            Raise a configuration changed event on this repository\r
+            </summary>\r
+            <param name="e">EventArgs.Empty</param>\r
+            <remarks>\r
+            <para>\r
+            Applications that programmatically change the configuration of the repository should\r
+            raise this event notification to notify listeners.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Name">\r
+            <summary>\r
+            The name of the repository\r
+            </summary>\r
+            <value>\r
+            The string name of the repository\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of this repository. The name is\r
+            used to store and lookup the repositories \r
+            stored by the <see cref="T:log4net.Core.IRepositorySelector"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Threshold">\r
+            <summary>\r
+            The threshold for all events in this repository\r
+            </summary>\r
+            <value>\r
+            The threshold for all events in this repository\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The threshold for all events in this repository\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.RendererMap">\r
+            <summary>\r
+            RendererMap accesses the object renderer map for this repository.\r
+            </summary>\r
+            <value>\r
+            RendererMap accesses the object renderer map for this repository.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            RendererMap accesses the object renderer map for this repository.\r
+            </para>\r
+            <para>\r
+            The RendererMap holds a mapping between types and\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/> objects.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.PluginMap">\r
+            <summary>\r
+            The plugin map for this repository.\r
+            </summary>\r
+            <value>\r
+            The plugin map for this repository.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The plugin map holds the <see cref="T:log4net.Plugin.IPlugin"/> instances\r
+            that have been attached to this repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.LevelMap">\r
+            <summary>\r
+            Get the level map for the Repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Get the level map for the Repository.\r
+            </para>\r
+            <para>\r
+            The level map defines the mappings between\r
+            level names and <see cref="T:log4net.Core.Level"/> objects in\r
+            this repository.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Configured">\r
+            <summary>\r
+            Flag indicates if this repository has been configured.\r
+            </summary>\r
+            <value>\r
+            Flag indicates if this repository has been configured.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Flag indicates if this repository has been configured.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.ConfigurationMessages">\r
+            <summary>\r
+            Contains a list of internal messages captures during the \r
+            last configuration.\r
+            </summary>\r
+        </member>\r
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ShutdownEvent">\r
+            <summary>\r
+            Event to notify that the repository has been shutdown.\r
+            </summary>\r
+            <value>\r
+            Event to notify that the repository has been shutdown.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when the repository has been shutdown.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationReset">\r
+            <summary>\r
+            Event to notify that the repository has had its configuration reset.\r
+            </summary>\r
+            <value>\r
+            Event to notify that the repository has had its configuration reset.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when the repository's configuration has been\r
+            reset to default.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Repository.LoggerRepositorySkeleton.ConfigurationChanged">\r
+            <summary>\r
+            Event to notify that the repository has had its configuration changed.\r
+            </summary>\r
+            <value>\r
+            Event to notify that the repository has had its configuration changed.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Event raised when the repository's configuration has been changed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.LoggerRepositorySkeleton.Properties">\r
+            <summary>\r
+            Repository specific properties\r
+            </summary>\r
+            <value>\r
+            Repository specific properties\r
+            </value>\r
+            <remarks>\r
+            These properties can be specified on a repository specific basis\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.IBasicRepositoryConfigurator">\r
+            <summary>\r
+            Basic Configurator interface for repositories\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface used by basic configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            with a default <see cref="T:log4net.Appender.IAppender"/>.\r
+            </para>\r
+            <para>\r
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support\r
+            configuration by the <see cref="T:log4net.Config.BasicConfigurator"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Initialize the repository using the specified appender\r
+            </summary>\r
+            <param name="appender">the appender to use to log all logging events</param>\r
+            <remarks>\r
+            <para>\r
+            Configure the repository to route all logging events to the\r
+            specified appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.IBasicRepositoryConfigurator.Configure(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Initialize the repository using the specified appenders\r
+            </summary>\r
+            <param name="appenders">the appenders to use to log all logging events</param>\r
+            <remarks>\r
+            <para>\r
+            Configure the repository to route all logging events to the\r
+            specified appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.IXmlRepositoryConfigurator">\r
+            <summary>\r
+            Configure repository using XML\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Interface used by Xml configurator to configure a <see cref="T:log4net.Repository.ILoggerRepository"/>.\r
+            </para>\r
+            <para>\r
+            A <see cref="T:log4net.Repository.ILoggerRepository"/> should implement this interface to support\r
+            configuration by the <see cref="T:log4net.Config.XmlConfigurator"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.IXmlRepositoryConfigurator.Configure(System.Xml.XmlElement)">\r
+            <summary>\r
+            Initialize the repository using the specified config\r
+            </summary>\r
+            <param name="element">the element containing the root of the config</param>\r
+            <remarks>\r
+            <para>\r
+            The schema for the XML configuration data is defined by\r
+            the implementation.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary)">\r
+            <summary>\r
+            Construct with properties\r
+            </summary>\r
+            <param name="properties">The properties to pass to this repository.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Repository.Hierarchy.ILoggerFactory)">\r
+            <summary>\r
+            Construct with a logger factory\r
+            </summary>\r
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with \r
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.#ctor(log4net.Util.PropertiesDictionary,log4net.Repository.Hierarchy.ILoggerFactory)">\r
+            <summary>\r
+            Construct with properties and a logger factory\r
+            </summary>\r
+            <param name="properties">The properties to pass to this repository.</param>\r
+            <param name="loggerFactory">The factory to use to create new logger instances.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> class with \r
+            the specified <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Exists(System.String)">\r
+            <summary>\r
+            Test if a logger exists\r
+            </summary>\r
+            <param name="name">The name of the logger to lookup</param>\r
+            <returns>The Logger object with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Check if the named logger exists in the hierarchy. If so return\r
+            its reference, otherwise returns <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetCurrentLoggers">\r
+            <summary>\r
+            Returns all the currently defined loggers in the hierarchy as an Array\r
+            </summary>\r
+            <returns>All the defined loggers</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns all the currently defined loggers in the hierarchy as an Array.\r
+            The root logger is <b>not</b> included in the returned\r
+            enumeration.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String)">\r
+            <summary>\r
+            Return a new logger instance named as the first parameter using\r
+            the default factory.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Return a new logger instance named as the first parameter using\r
+            the default factory.\r
+            </para>\r
+            <para>\r
+            If a logger of that name already exists, then it will be\r
+            returned.  Otherwise, a new logger will be instantiated and\r
+            then linked with its existing ancestors as well as children.\r
+            </para>\r
+            </remarks>\r
+            <param name="name">The name of the logger to retrieve</param>\r
+            <returns>The logger object with the name specified</returns>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Shutdown">\r
+            <summary>\r
+            Shutting down a hierarchy will <i>safely</i> close and remove\r
+            all appenders in all loggers including the root logger.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Shutting down a hierarchy will <i>safely</i> close and remove\r
+            all appenders in all loggers including the root logger.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the\r
+            application exists. Otherwise, pending logging events might be\r
+            lost.\r
+            </para>\r
+            <para>\r
+            The <c>Shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.ResetConfiguration">\r
+            <summary>\r
+            Reset all values contained in this hierarchy instance to their default.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Reset all values contained in this hierarchy instance to their\r
+            default.  This removes all appenders from all loggers, sets\r
+            the level of all non-root loggers to <c>null</c>,\r
+            sets their additivity flag to <c>true</c> and sets the level\r
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,\r
+            message disabling is set its default "off" value.\r
+            </para>\r
+            <para>\r
+            Existing loggers are not removed. They are just reset.\r
+            </para>\r
+            <para>\r
+            This method should be used sparingly and with care as it will\r
+            block all logging until it is completed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Log(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Log the logEvent through this hierarchy.\r
+            </summary>\r
+            <param name="logEvent">the event to log</param>\r
+            <remarks>\r
+            <para>\r
+            This method should not normally be used to log.\r
+            The <see cref="T:log4net.ILog"/> interface should be used \r
+            for routine logging. This interface can be obtained\r
+            using the <see cref="M:log4net.LogManager.GetLogger(string)"/> method.\r
+            </para>\r
+            <para>\r
+            The <c>logEvent</c> is delivered to the appropriate logger and\r
+            that logger is then responsible for logging the event.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetAppenders">\r
+            <summary>\r
+            Returns all the Appenders that are currently configured\r
+            </summary>\r
+            <returns>An array containing all the currently configured appenders</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns all the <see cref="T:log4net.Appender.IAppender"/> instances that are currently configured.\r
+            All the loggers are searched for appenders. The appenders may also be containers\r
+            for appenders and these are also searched for additional loggers.\r
+            </para>\r
+            <para>\r
+            The list returned is unordered but does not contain duplicates.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppender(System.Collections.ArrayList,log4net.Appender.IAppender)">\r
+            <summary>\r
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/>.\r
+            The appender may also be a container.\r
+            </summary>\r
+            <param name="appenderList"></param>\r
+            <param name="appender"></param>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.CollectAppenders(System.Collections.ArrayList,log4net.Core.IAppenderAttachable)">\r
+            <summary>\r
+            Collect the appenders from an <see cref="T:log4net.Core.IAppenderAttachable"/> container\r
+            </summary>\r
+            <param name="appenderList"></param>\r
+            <param name="container"></param>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Initialize the log4net system using the specified appender\r
+            </summary>\r
+            <param name="appender">the appender to use to log all logging events</param>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IBasicRepositoryConfigurator#Configure(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Initialize the log4net system using the specified appenders\r
+            </summary>\r
+            <param name="appenders">the appenders to use to log all logging events</param>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.BasicRepositoryConfigure(log4net.Appender.IAppender[])">\r
+            <summary>\r
+            Initialize the log4net system using the specified appenders\r
+            </summary>\r
+            <param name="appenders">the appenders to use to log all logging events</param>\r
+            <remarks>\r
+            <para>\r
+            This method provides the same functionality as the \r
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented\r
+            on this object, but it is protected and therefore can be called by subclasses.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.log4net#Repository#IXmlRepositoryConfigurator#Configure(System.Xml.XmlElement)">\r
+            <summary>\r
+            Initialize the log4net system using the specified config\r
+            </summary>\r
+            <param name="element">the element containing the root of the config</param>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.XmlRepositoryConfigure(System.Xml.XmlElement)">\r
+            <summary>\r
+            Initialize the log4net system using the specified config\r
+            </summary>\r
+            <param name="element">the element containing the root of the config</param>\r
+            <remarks>\r
+            <para>\r
+            This method provides the same functionality as the \r
+            <see cref="M:IBasicRepositoryConfigurator.Configure(IAppender)"/> method implemented\r
+            on this object, but it is protected and therefore can be called by subclasses.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.IsDisabled(log4net.Core.Level)">\r
+            <summary>\r
+            Test if this hierarchy is disabled for the specified <see cref="T:log4net.Core.Level"/>.\r
+            </summary>\r
+            <param name="level">The level to check against.</param>\r
+            <returns>\r
+            <c>true</c> if the repository is disabled for the level argument, <c>false</c> otherwise.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            If this hierarchy has not been configured then this method will\r
+            always return <c>true</c>.\r
+            </para>\r
+            <para>\r
+            This method will return <c>true</c> if this repository is\r
+            disabled for <c>level</c> object passed as parameter and\r
+            <c>false</c> otherwise.\r
+            </para>\r
+            <para>\r
+            See also the <see cref="P:log4net.Repository.ILoggerRepository.Threshold"/> property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.Clear">\r
+            <summary>\r
+            Clear all logger definitions from the internal hashtable\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This call will clear all logger definitions from the internal\r
+            hashtable. Invoking this method will irrevocably mess up the\r
+            logger hierarchy.\r
+            </para>\r
+            <para>\r
+            You should <b>really</b> know what you are doing before\r
+            invoking this method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.GetLogger(System.String,log4net.Repository.Hierarchy.ILoggerFactory)">\r
+            <summary>\r
+            Return a new logger instance named as the first parameter using\r
+            <paramref name="factory"/>.\r
+            </summary>\r
+            <param name="name">The name of the logger to retrieve</param>\r
+            <param name="factory">The factory that will make the new logger instance</param>\r
+            <returns>The logger object with the name specified</returns>\r
+            <remarks>\r
+            <para>\r
+            If a logger of that name already exists, then it will be\r
+            returned. Otherwise, a new logger will be instantiated by the\r
+            <paramref name="factory"/> parameter and linked with its existing\r
+            ancestors as well as children.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.OnLoggerCreationEvent(log4net.Repository.Hierarchy.Logger)">\r
+            <summary>\r
+            Sends a logger creation event to all registered listeners\r
+            </summary>\r
+            <param name="logger">The newly created logger</param>\r
+            <remarks>\r
+            Raises the logger creation event.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateParents(log4net.Repository.Hierarchy.Logger)">\r
+            <summary>\r
+            Updates all the parents of the specified logger\r
+            </summary>\r
+            <param name="log">The logger to update the parents for</param>\r
+            <remarks>\r
+            <para>\r
+            This method loops through all the <i>potential</i> parents of\r
+            <paramref name="log"/>. There 3 possible cases:\r
+            </para>\r
+            <list type="number">\r
+               <item>\r
+                       <term>No entry for the potential parent of <paramref name="log"/> exists</term>\r
+                       <description>\r
+                       We create a ProvisionNode for this potential \r
+                       parent and insert <paramref name="log"/> in that provision node.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>The entry is of type Logger for the potential parent.</term>\r
+                       <description>\r
+                       The entry is <paramref name="log"/>'s nearest existing parent. We \r
+                       update <paramref name="log"/>'s parent field with this entry. We also break from \r
+                       he loop because updating our parent's parent is our parent's \r
+                       responsibility.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>The entry is of type ProvisionNode for this potential parent.</term>\r
+                       <description>\r
+                       We add <paramref name="log"/> to the list of children for this \r
+                       potential parent.\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.UpdateChildren(log4net.Repository.Hierarchy.ProvisionNode,log4net.Repository.Hierarchy.Logger)">\r
+            <summary>\r
+            Replace a <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> with a <see cref="T:log4net.Repository.Hierarchy.Logger"/> in the hierarchy.\r
+            </summary>\r
+            <param name="pn"></param>\r
+            <param name="log"></param>\r
+            <remarks>\r
+            <para>\r
+            We update the links for all the children that placed themselves\r
+            in the provision node 'pn'. The second argument 'log' is a\r
+            reference for the newly created Logger, parent of all the\r
+            children in 'pn'.\r
+            </para>\r
+            <para>\r
+            We loop on all the children 'c' in 'pn'.\r
+            </para>\r
+            <para>\r
+            If the child 'c' has been already linked to a child of\r
+            'log' then there is no need to update 'c'.\r
+            </para>\r
+            <para>\r
+            Otherwise, we set log's parent field to c's parent and set\r
+            c's parent field to log.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddLevel(log4net.Repository.Hierarchy.Hierarchy.LevelEntry)">\r
+            <summary>\r
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument\r
+            </summary>\r
+            <param name="levelEntry">the level values</param>\r
+            <remarks>\r
+            <para>\r
+            Define or redefine a Level using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument\r
+            </para>\r
+            <para>\r
+            Supports setting levels via the configuration file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.AddProperty(log4net.Util.PropertyEntry)">\r
+            <summary>\r
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument\r
+            </summary>\r
+            <param name="propertyEntry">the property value</param>\r
+            <remarks>\r
+            <para>\r
+            Set a Property using the values in the <see cref="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry"/> argument.\r
+            </para>\r
+            <para>\r
+            Supports setting property values via the configuration file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.Hierarchy.declaringType">\r
+            <summary>\r
+            The fully qualified type of the Hierarchy class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="E:log4net.Repository.Hierarchy.Hierarchy.LoggerCreatedEvent">\r
+            <summary>\r
+            Event used to notify that a logger has been created.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Event raised when a logger is created.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.EmittedNoAppenderWarning">\r
+            <summary>\r
+            Has no appender warning been emitted\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Flag to indicate if we have already issued a warning\r
+            about not having an appender warning.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.Root">\r
+            <summary>\r
+            Get the root of this hierarchy\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Get the root of this hierarchy.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LoggerFactory">\r
+            <summary>\r
+            Gets or sets the default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/> instance.\r
+            </summary>\r
+            <value>The default <see cref="T:log4net.Repository.Hierarchy.ILoggerFactory"/></value>\r
+            <remarks>\r
+            <para>\r
+            The logger factory is used to create logger instances.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.Hierarchy.LevelEntry">\r
+            <summary>\r
+            A class to hold the value, name and display name for a level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A class to hold the value, name and display name for a level\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.ToString">\r
+            <summary>\r
+            Override <c>Object.ToString</c> to return sensible debug info\r
+            </summary>\r
+            <returns>string info about this object</returns>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Value">\r
+            <summary>\r
+            Value of the level\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If the value is not set (defaults to -1) the value will be looked\r
+            up for the current level with the same name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.Name">\r
+            <summary>\r
+            Name of the level\r
+            </summary>\r
+            <value>\r
+            The name of the level\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The name of the level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.Hierarchy.LevelEntry.DisplayName">\r
+            <summary>\r
+            Display name for the level\r
+            </summary>\r
+            <value>\r
+            The display name of the level\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The display name of the level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.LoggerKey">\r
+            <summary>\r
+            Used internally to accelerate hash table searches.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Internal class used to improve performance of \r
+            string keyed hashtables.\r
+            </para>\r
+            <para>\r
+            The hashcode of the string is cached for reuse.\r
+            The string is stored as an interned value.\r
+            When comparing two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> objects for equality \r
+            the reference equality of the interned strings is compared.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.#ctor(System.String)">\r
+            <summary>\r
+            Construct key with string name\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> class \r
+            with the specified name.\r
+            </para>\r
+            <para>\r
+            Stores the hashcode of the string and interns\r
+            the string key to optimize comparisons.\r
+            </para>\r
+            <note>\r
+            The Compact Framework 1.0 the <see cref="M:System.String.Intern(System.String)"/>\r
+            method does not work. On the Compact Framework\r
+            the string keys are not interned nor are they\r
+            compared by reference.\r
+            </note>\r
+            </remarks>\r
+            <param name="name">The name of the logger.</param>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.GetHashCode">\r
+            <summary>\r
+            Returns a hash code for the current instance.\r
+            </summary>\r
+            <returns>A hash code for the current instance.</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns the cached hashcode.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.LoggerKey.Equals(System.Object)">\r
+            <summary>\r
+            Determines whether two <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/> instances \r
+            are equal.\r
+            </summary>\r
+            <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>.</param>\r
+            <returns>\r
+            <c>true</c> if the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:log4net.Repository.Hierarchy.LoggerKey"/>; otherwise, <c>false</c>.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Compares the references of the interned strings.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.ProvisionNode">\r
+            <summary>\r
+            Provision nodes are used where no logger instance has been specified\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> instances are used in the \r
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> when there is no specified \r
+            <see cref="T:log4net.Repository.Hierarchy.Logger"/> for that node.\r
+            </para>\r
+            <para>\r
+            A provision node holds a list of child loggers on behalf of\r
+            a logger that does not exist.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.ProvisionNode.#ctor(log4net.Repository.Hierarchy.Logger)">\r
+            <summary>\r
+            Create a new provision node with child node\r
+            </summary>\r
+            <param name="log">A child logger to add to this node.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.ProvisionNode"/> class \r
+            with the specified child logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.RootLogger">\r
+            <summary>\r
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> sits at the root of the logger hierarchy tree. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> is a regular <see cref="T:log4net.Repository.Hierarchy.Logger"/> except \r
+            that it provides several guarantees.\r
+            </para>\r
+            <para>\r
+            First, it cannot be assigned a <c>null</c>\r
+            level. Second, since the root logger cannot have a parent, the\r
+            <see cref="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel"/> property always returns the value of the\r
+            level field without walking the hierarchy.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.RootLogger.#ctor(log4net.Core.Level)">\r
+            <summary>\r
+            Construct a <see cref="T:log4net.Repository.Hierarchy.RootLogger"/>\r
+            </summary>\r
+            <param name="level">The level to assign to the root logger.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.RootLogger"/> class with\r
+            the specified logging level.\r
+            </para>\r
+            <para>\r
+            The root logger names itself as "root". However, the root\r
+            logger cannot be retrieved by name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.RootLogger.declaringType">\r
+            <summary>\r
+            The fully qualified type of the RootLogger class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.EffectiveLevel">\r
+            <summary>\r
+            Gets the assigned level value without walking the logger hierarchy.\r
+            </summary>\r
+            <value>The assigned level value without walking the logger hierarchy.</value>\r
+            <remarks>\r
+            <para>\r
+            Because the root logger cannot have a parent and its level\r
+            must not be <c>null</c> this property just returns the\r
+            value of <see cref="P:log4net.Repository.Hierarchy.Logger.Level"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Repository.Hierarchy.RootLogger.Level">\r
+            <summary>\r
+            Gets or sets the assigned <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> for the root logger.  \r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Repository.Hierarchy.RootLogger.Level"/> of the root logger.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Setting the level of the root logger to a <c>null</c> reference\r
+            may have catastrophic results. We prevent this here.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator">\r
+            <summary>\r
+            Initializes the log4net environment using an XML DOM.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Configures a <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> using an XML DOM.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.#ctor(log4net.Repository.Hierarchy.Hierarchy)">\r
+            <summary>\r
+            Construct the configurator for a hierarchy\r
+            </summary>\r
+            <param name="hierarchy">The hierarchy to build.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Repository.Hierarchy.XmlHierarchyConfigurator"/> class\r
+            with the specified <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.Configure(System.Xml.XmlElement)">\r
+            <summary>\r
+            Configure the hierarchy by parsing a DOM tree of XML elements.\r
+            </summary>\r
+            <param name="element">The root element to parse.</param>\r
+            <remarks>\r
+            <para>\r
+            Configure the hierarchy by parsing a DOM tree of XML elements.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindAppenderByReference(System.Xml.XmlElement)">\r
+            <summary>\r
+            Parse appenders by IDREF.\r
+            </summary>\r
+            <param name="appenderRef">The appender ref element.</param>\r
+            <returns>The instance of the appender that the ref refers to.</returns>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element that represents an appender and return \r
+            the appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseAppender(System.Xml.XmlElement)">\r
+            <summary>\r
+            Parses an appender element.\r
+            </summary>\r
+            <param name="appenderElement">The appender element.</param>\r
+            <returns>The appender instance or <c>null</c> when parsing failed.</returns>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element that represents an appender and return\r
+            the appender instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLogger(System.Xml.XmlElement)">\r
+            <summary>\r
+            Parses a logger element.\r
+            </summary>\r
+            <param name="loggerElement">The logger element.</param>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element that represents a logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRoot(System.Xml.XmlElement)">\r
+            <summary>\r
+            Parses the root logger element.\r
+            </summary>\r
+            <param name="rootElement">The root element.</param>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element that represents the root logger.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseChildrenOfLoggerElement(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">\r
+            <summary>\r
+            Parses the children of a logger element.\r
+            </summary>\r
+            <param name="catElement">The category element.</param>\r
+            <param name="log">The logger instance.</param>\r
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>\r
+            <remarks>\r
+            <para>\r
+            Parse the child elements of a &lt;logger&gt; element.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseRenderer(System.Xml.XmlElement)">\r
+            <summary>\r
+            Parses an object renderer.\r
+            </summary>\r
+            <param name="element">The renderer element.</param>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element that represents a renderer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ParseLevel(System.Xml.XmlElement,log4net.Repository.Hierarchy.Logger,System.Boolean)">\r
+            <summary>\r
+            Parses a level element.\r
+            </summary>\r
+            <param name="element">The level element.</param>\r
+            <param name="log">The logger object to set the level on.</param>\r
+            <param name="isRoot">Flag to indicate if the logger is the root logger.</param>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element that represents a level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.SetParameter(System.Xml.XmlElement,System.Object)">\r
+            <summary>\r
+            Sets a parameter on an object.\r
+            </summary>\r
+            <param name="element">The parameter element.</param>\r
+            <param name="target">The object to set the parameter on.</param>\r
+            <remarks>\r
+            The parameter name must correspond to a writable property\r
+            on the object. The value of the parameter is a string,\r
+            therefore this function will attempt to set a string\r
+            property first. If unable to set a string property it\r
+            will inspect the property and its argument type. It will\r
+            attempt to call a static method called <c>Parse</c> on the\r
+            type of the property. This method will take a single\r
+            string argument and return a value that can be used to\r
+            set the property.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.HasAttributesOrElements(System.Xml.XmlElement)">\r
+            <summary>\r
+            Test if an element has no attributes or child elements\r
+            </summary>\r
+            <param name="element">the element to inspect</param>\r
+            <returns><c>true</c> if the element has any attributes or child elements, <c>false</c> otherwise</returns>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.IsTypeConstructible(System.Type)">\r
+            <summary>\r
+            Test if a <see cref="T:System.Type"/> is constructible with <c>Activator.CreateInstance</c>.\r
+            </summary>\r
+            <param name="type">the type to inspect</param>\r
+            <returns><c>true</c> if the type is creatable using a default constructor, <c>false</c> otherwise</returns>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.FindMethodInfo(System.Type,System.String)">\r
+            <summary>\r
+            Look for a method on the <paramref name="targetType"/> that matches the <paramref name="name"/> supplied\r
+            </summary>\r
+            <param name="targetType">the type that has the method</param>\r
+            <param name="name">the name of the method</param>\r
+            <returns>the method info found</returns>\r
+            <remarks>\r
+            <para>\r
+            The method must be a public instance method on the <paramref name="targetType"/>.\r
+            The method must be named <paramref name="name"/> or "Add" followed by <paramref name="name"/>.\r
+            The method must take a single parameter.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.ConvertStringTo(System.Type,System.String)">\r
+            <summary>\r
+            Converts a string value to a target type.\r
+            </summary>\r
+            <param name="type">The type of object to convert the string to.</param>\r
+            <param name="value">The string value to use as the value of the object.</param>\r
+            <returns>\r
+            <para>\r
+            An object of type <paramref name="type"/> with value <paramref name="value"/> or \r
+            <c>null</c> when the conversion could not be performed.\r
+            </para>\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.CreateObjectFromXml(System.Xml.XmlElement,System.Type,System.Type)">\r
+            <summary>\r
+            Creates an object as specified in XML.\r
+            </summary>\r
+            <param name="element">The XML element that contains the definition of the object.</param>\r
+            <param name="defaultTargetType">The object type to use if not explicitly specified.</param>\r
+            <param name="typeConstraint">The type that the returned object must be or must inherit from.</param>\r
+            <returns>The object or <c>null</c></returns>\r
+            <remarks>\r
+            <para>\r
+            Parse an XML element and create an object instance based on the configuration\r
+            data.\r
+            </para>\r
+            <para>\r
+            The type of the instance may be specified in the XML. If not\r
+            specified then the <paramref name="defaultTargetType"/> is used\r
+            as the type. However the type is specified it must support the\r
+            <paramref name="typeConstraint"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_appenderBag">\r
+            <summary>\r
+            key: appenderName, value: appender.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.m_hierarchy">\r
+            <summary>\r
+            The Hierarchy being configured.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Repository.Hierarchy.XmlHierarchyConfigurator.declaringType">\r
+            <summary>\r
+            The fully qualified type of the XmlHierarchyConfigurator class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.ConfigurationChangedEventArgs">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Repository.ConfigurationChangedEventArgs.#ctor(System.Collections.ICollection)">\r
+            <summary>\r
+            \r
+            </summary>\r
+            <param name="configurationMessages"></param>\r
+        </member>\r
+        <member name="P:log4net.Repository.ConfigurationChangedEventArgs.ConfigurationMessages">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Repository.LoggerRepositoryShutdownEventHandler">\r
+            <summary>\r
+            Delegate used to handle logger repository shutdown event notifications\r
+            </summary>\r
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that is shutting down.</param>\r
+            <param name="e">Empty event args</param>\r
+            <remarks>\r
+            <para>\r
+            Delegate used to handle logger repository shutdown event notifications.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationResetEventHandler">\r
+            <summary>\r
+            Delegate used to handle logger repository configuration reset event notifications\r
+            </summary>\r
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration reset.</param>\r
+            <param name="e">Empty event args</param>\r
+            <remarks>\r
+            <para>\r
+            Delegate used to handle logger repository configuration reset event notifications.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Repository.LoggerRepositoryConfigurationChangedEventHandler">\r
+            <summary>\r
+            Delegate used to handle event notifications for logger repository configuration changes.\r
+            </summary>\r
+            <param name="sender">The <see cref="T:log4net.Repository.ILoggerRepository"/> that has had its configuration changed.</param>\r
+            <param name="e">Empty event arguments.</param>\r
+            <remarks>\r
+            <para>\r
+            Delegate used to handle event notifications for logger repository configuration changes.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.AppDomainPatternConverter">\r
+            <summary>\r
+            Write the name of the current AppDomain to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Write the name of the current AppDomain to the output writer\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.AppDomainPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the name of the current AppDomain to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Writes name of the current AppDomain to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.DatePatternConverter">\r
+            <summary>\r
+            Write the current date to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format \r
+            the current date and time to the writer as a string.\r
+            </para>\r
+            <para>\r
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines \r
+            the formatting of the date. The following values are allowed:\r
+            <list type="definition">\r
+               <listheader>\r
+                       <term>Option value</term>\r
+                       <description>Output</description>\r
+               </listheader>\r
+               <item>\r
+                       <term>ISO8601</term>\r
+                       <description>\r
+                       Uses the <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/> formatter. \r
+                       Formats using the <c>"yyyy-MM-dd HH:mm:ss,fff"</c> pattern.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>DATE</term>\r
+                       <description>\r
+                       Uses the <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> formatter. \r
+                       Formats using the <c>"dd MMM yyyy HH:mm:ss,fff"</c> for example, <c>"06 Nov 1994 15:49:37,459"</c>.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>ABSOLUTE</term>\r
+                       <description>\r
+                       Uses the <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/> formatter. \r
+                       Formats using the <c>"HH:mm:ss,fff"</c> for example, <c>"15:49:37,459"</c>.\r
+                       </description>\r
+               </item>\r
+               <item>\r
+                       <term>other</term>\r
+                       <description>\r
+                       Any other pattern string uses the <see cref="T:log4net.DateFormatter.SimpleDateFormatter"/> formatter. \r
+                       This formatter passes the pattern string to the <see cref="T:System.DateTime"/> \r
+                       <see cref="M:DateTime.ToString(string)"/> method.\r
+                       For details on valid patterns see \r
+                       <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemglobalizationdatetimeformatinfoclasstopic.asp">DateTimeFormatInfo Class</a>.\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            </para>\r
+            <para>\r
+            The date and time is in the local time zone and is rendered in that zone.\r
+            To output the time in Universal time see <see cref="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.m_dateFormatter">\r
+            <summary>\r
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.DateFormatter.IDateFormatter"/> used to render the date to a string\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions">\r
+            <summary>\r
+            Initialize the converter options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Util.PatternStringConverters.DatePatternConverter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.DatePatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the current date to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>\r
+            for it to render it to the writer.\r
+            </para>\r
+            <para>\r
+            The date and time passed is in the local time zone.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.DatePatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the DatePatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter">\r
+            <summary>\r
+            Write an <see cref="T:System.Environment.SpecialFolder"/> folder path to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Write an special path environment folder path to the output writer.\r
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines \r
+            the name of the variable to output. <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            should be a value in the <see cref="T:System.Environment.SpecialFolder"/> enumeration.\r
+            </para>\r
+            </remarks>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write an special path environment folder path to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the special path environment folder path to the output <paramref name="writer"/>.\r
+            The name of the special path environment folder path to output must be set\r
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentFolderPathPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the EnvironmentFolderPathPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.EnvironmentPatternConverter">\r
+            <summary>\r
+            Write an environment variable to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Write an environment variable to the output writer.\r
+            The value of the <see cref="P:log4net.Util.PatternConverter.Option"/> determines \r
+            the name of the variable to output.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write an environment variable to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the environment variable to the output <paramref name="writer"/>.\r
+            The name of the environment variable to output must be set\r
+            using the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.EnvironmentPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the EnvironmentPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.IdentityPatternConverter">\r
+            <summary>\r
+            Write the current thread identity to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Write the current thread identity to the output writer\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.IdentityPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the current thread identity to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Writes the current thread identity to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.IdentityPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the IdentityPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.LiteralPatternConverter">\r
+            <summary>\r
+            Pattern converter for literal string instances in the pattern\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the literal string value specified in the \r
+            <see cref="P:log4net.Util.PatternConverter.Option"/> property to \r
+            the output.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.SetNext(log4net.Util.PatternConverter)">\r
+            <summary>\r
+            Set the next converter in the chain\r
+            </summary>\r
+            <param name="pc">The next pattern converter in the chain</param>\r
+            <returns>The next pattern converter</returns>\r
+            <remarks>\r
+            <para>\r
+            Special case the building of the pattern converter chain\r
+            for <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> instances. Two adjacent\r
+            literals in the pattern can be represented by a single combined\r
+            pattern converter. This implementation detects when a \r
+            <see cref="T:log4net.Util.PatternStringConverters.LiteralPatternConverter"/> is added to the chain\r
+            after this converter and combines its value with this converter's\r
+            literal value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Format(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the literal to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, not set</param>\r
+            <remarks>\r
+            <para>\r
+            Override the formatting behavior to ignore the FormattingInfo\r
+            because we have a literal instead.\r
+            </para>\r
+            <para>\r
+            Writes the value of <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.LiteralPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Convert this pattern into the rendered message\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">null, not set</param>\r
+            <remarks>\r
+            <para>\r
+            This method is not used.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.NewLinePatternConverter">\r
+            <summary>\r
+            Writes a newline to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Writes the system dependent line terminator to the output.\r
+            This behavior can be overridden by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>:\r
+            </para>\r
+            <list type="definition">\r
+              <listheader>\r
+                <term>Option Value</term>\r
+                <description>Output</description>\r
+              </listheader>\r
+              <item>\r
+                <term>DOS</term>\r
+                <description>DOS or Windows line terminator <c>"\r\n"</c></description>\r
+              </item>\r
+              <item>\r
+                <term>UNIX</term>\r
+                <description>UNIX line terminator <c>"\n"</c></description>\r
+              </item>\r
+            </list>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions">\r
+            <summary>\r
+            Initialize the converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Util.PatternStringConverters.NewLinePatternConverter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.ProcessIdPatternConverter">\r
+            <summary>\r
+            Write the current process ID to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Write the current process ID to the output writer\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the current process ID to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Write the current process ID to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.ProcessIdPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the ProcessIdPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.PropertyPatternConverter">\r
+            <summary>\r
+            Property pattern converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This pattern converter reads the thread and global properties.\r
+            The thread properties take priority over global properties.\r
+            See <see cref="P:log4net.ThreadContext.Properties"/> for details of the \r
+            thread properties. See <see cref="P:log4net.GlobalContext.Properties"/> for\r
+            details of the global properties.\r
+            </para>\r
+            <para>\r
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is specified then that will be used to\r
+            lookup a single property. If no <see cref="P:log4net.Util.PatternConverter.Option"/> is specified\r
+            then all properties will be dumped as a list of key value pairs.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.PropertyPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the property value to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Writes out the value of a named property. The property name\r
+            should be set in the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            property.\r
+            </para>\r
+            <para>\r
+            If the <see cref="P:log4net.Util.PatternConverter.Option"/> is set to <c>null</c>\r
+            then all the properties are written as key value pairs.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.RandomStringPatternConverter">\r
+            <summary>\r
+            A Pattern converter that generates a string of random characters\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The converter generates a string of random characters. By default\r
+            the string is length 4. This can be changed by setting the <see cref="P:log4net.Util.PatternConverter.Option"/>\r
+            to the string value of the length required.\r
+            </para>\r
+            <para>\r
+            The random characters in the string are limited to uppercase letters\r
+            and numbers only.\r
+            </para>\r
+            <para>\r
+            The random number generator used by this class is not cryptographically secure.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.s_random">\r
+            <summary>\r
+            Shared random number generator\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.m_length">\r
+            <summary>\r
+            Length of random string to generate. Default length 4.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions">\r
+            <summary>\r
+            Initialize the converter options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.RandomStringPatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write a randoim string to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Write a randoim string to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.RandomStringPatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the RandomStringPatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.UserNamePatternConverter">\r
+            <summary>\r
+            Write the current threads username to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Write the current threads username to the output writer\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.UserNamePatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the current threads username to the output\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Write the current threads username to the output <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.UserNamePatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the UserNamePatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternStringConverters.UtcDatePatternConverter">\r
+            <summary>\r
+            Write the UTC date time to the output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Date pattern converter, uses a <see cref="T:log4net.DateFormatter.IDateFormatter"/> to format \r
+            the current date and time in Universal time.\r
+            </para>\r
+            <para>\r
+            See the <see cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/> for details on the date pattern syntax.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternStringConverters.UtcDatePatternConverter.Convert(System.IO.TextWriter,System.Object)">\r
+            <summary>\r
+            Write the current date and time to the output\r
+            </summary>\r
+            <param name="writer"><see cref="T:System.IO.TextWriter"/> that will receive the formatted result.</param>\r
+            <param name="state">null, state is not set</param>\r
+            <remarks>\r
+            <para>\r
+            Pass the current date and time to the <see cref="T:log4net.DateFormatter.IDateFormatter"/>\r
+            for it to render it to the writer.\r
+            </para>\r
+            <para>\r
+            The date is in Universal time when it is rendered.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.PatternStringConverters.DatePatternConverter"/>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternStringConverters.UtcDatePatternConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the UtcDatePatternConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.BooleanConverter">\r
+            <summary>\r
+            Type converter for Boolean.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Supports conversion from string to <c>bool</c> type.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="sourceType"/> is\r
+            the <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.BooleanConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Convert the source object to the type supported by this object\r
+            </summary>\r
+            <param name="source">the object to convert</param>\r
+            <returns>the converted object</returns>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:System.Boolean.Parse(System.String)"/> method to convert the\r
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Boolean"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)"/>\r
+            method.\r
+            </exception>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            <summary>\r
+            Exception base type for conversion errors.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This type extends <see cref="T:System.ApplicationException"/>. It\r
+            does not add any new functionality but does differentiate the\r
+            type of exception being thrown.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="message">A message to include with the exception.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class\r
+            with the specified message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.String,System.Exception)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="message">A message to include with the exception.</param>\r
+            <param name="innerException">A nested exception to include.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class\r
+            with the specified message and inner exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serialization constructor\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>\r
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class \r
+            with serialized data.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object)">\r
+            <summary>\r
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.\r
+            </summary>\r
+            <param name="destinationType">The conversion destination type.</param>\r
+            <param name="sourceValue">The value to convert.</param>\r
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConversionNotSupportedException.Create(System.Type,System.Object,System.Exception)">\r
+            <summary>\r
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.\r
+            </summary>\r
+            <param name="destinationType">The conversion destination type.</param>\r
+            <param name="sourceValue">The value to convert.</param>\r
+            <param name="innerException">A nested exception to include.</param>\r
+            <returns>An instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Creates a new instance of the <see cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.ConverterRegistry">\r
+            <summary>\r
+            Register of type converters for specific types.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Maintains a registry of type converters used to convert between\r
+            types.\r
+            </para>\r
+            <para>\r
+            Use the <see cref="M:AddConverter(Type, object)"/> and \r
+            <see cref="M:AddConverter(Type, Type)"/> methods to register new converters.\r
+            The <see cref="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)"/> and <see cref="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)"/> methods\r
+            lookup appropriate converters to use.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#ctor">\r
+            <summary>\r
+            Private constructor\r
+            </summary>\r
+            <remarks>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.TypeConverters.ConverterRegistry"/> class.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.#cctor">\r
+            <summary>\r
+            Static constructor.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This constructor defines the intrinsic type converters.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Object)">\r
+            <summary>\r
+            Adds a converter for a specific type.\r
+            </summary>\r
+            <param name="destinationType">The type being converted to.</param>\r
+            <param name="converter">The type converter to use to convert to the destination type.</param>\r
+            <remarks>\r
+            <para>\r
+            Adds a converter instance for a specific type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.AddConverter(System.Type,System.Type)">\r
+            <summary>\r
+            Adds a converter for a specific type.\r
+            </summary>\r
+            <param name="destinationType">The type being converted to.</param>\r
+            <param name="converterType">The type of the type converter to use to convert to the destination type.</param>\r
+            <remarks>\r
+            <para>\r
+            Adds a converter <see cref="T:System.Type"/> for a specific type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertTo(System.Type,System.Type)">\r
+            <summary>\r
+            Gets the type converter to use to convert values to the destination type.\r
+            </summary>\r
+            <param name="sourceType">The type being converted from.</param>\r
+            <param name="destinationType">The type being converted to.</param>\r
+            <returns>\r
+            The type converter instance to use for type conversions or <c>null</c> \r
+            if no type converter is found.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the type converter to use to convert values to the destination type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConvertFrom(System.Type)">\r
+            <summary>\r
+            Gets the type converter to use to convert values to the destination type.\r
+            </summary>\r
+            <param name="destinationType">The type being converted to.</param>\r
+            <returns>\r
+            The type converter instance to use for type conversions or <c>null</c> \r
+            if no type converter is found.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the type converter to use to convert values to the destination type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.GetConverterFromAttribute(System.Type)">\r
+            <summary>\r
+            Lookups the type converter to use as specified by the attributes on the \r
+            destination type.\r
+            </summary>\r
+            <param name="destinationType">The type being converted to.</param>\r
+            <returns>\r
+            The type converter instance to use for type conversions or <c>null</c> \r
+            if no type converter is found.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.ConverterRegistry.CreateConverterInstance(System.Type)">\r
+            <summary>\r
+            Creates the instance of the type converter.\r
+            </summary>\r
+            <param name="converterType">The type of the type converter.</param>\r
+            <returns>\r
+            The type converter instance to use for type conversions or <c>null</c> \r
+            if no type converter is found.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            The type specified for the type converter must implement \r
+            the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> or <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces \r
+            and must have a public default (no argument) constructor.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.declaringType">\r
+            <summary>\r
+            The fully qualified type of the ConverterRegistry class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.TypeConverters.ConverterRegistry.s_type2converter">\r
+            <summary>\r
+            Mapping from <see cref="T:System.Type"/> to type converter.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.EncodingConverter">\r
+            <summary>\r
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Supports conversion from string to <see cref="T:System.Text.Encoding"/> type.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="sourceType"/> is\r
+            the <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.EncodingConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Overrides the ConvertFrom method of IConvertFrom.\r
+            </summary>\r
+            <param name="source">the object to convert to an encoding</param>\r
+            <returns>the encoding</returns>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to \r
+            convert the <see cref="T:System.String"/> argument to an <see cref="T:System.Text.Encoding"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.EncodingConverter.CanConvertFrom(System.Type)"/>\r
+            method.\r
+            </exception>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.IConvertTo">\r
+            <summary>\r
+            Interface supported by type converters\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This interface supports conversion from a single type to arbitrary types.\r
+            See <see cref="T:log4net.Util.TypeConverters.TypeConverterAttribute"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.CanConvertTo(System.Type)">\r
+            <summary>\r
+            Returns whether this converter can convert the object to the specified type\r
+            </summary>\r
+            <param name="targetType">A Type that represents the type you want to convert to</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if the type supported by this converter can be converted to the\r
+            <paramref name="targetType"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.IConvertTo.ConvertTo(System.Object,System.Type)">\r
+            <summary>\r
+            Converts the given value object to the specified type, using the arguments\r
+            </summary>\r
+            <param name="source">the object to convert</param>\r
+            <param name="targetType">The Type to convert the value parameter to</param>\r
+            <returns>the converted object</returns>\r
+            <remarks>\r
+            <para>\r
+            Converts the <paramref name="source"/> (which must be of the type supported\r
+            by this converter) to the <paramref name="targetType"/> specified..\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.IPAddressConverter">\r
+            <summary>\r
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Supports conversion from string to <see cref="T:System.Net.IPAddress"/> type.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="sourceType"/> is\r
+            the <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.IPAddressConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Overrides the ConvertFrom method of IConvertFrom.\r
+            </summary>\r
+            <param name="source">the object to convert to an IPAddress</param>\r
+            <returns>the IPAddress</returns>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:System.Net.IPAddress.Parse(System.String)"/> method to convert the\r
+            <see cref="T:System.String"/> argument to an <see cref="T:System.Net.IPAddress"/>.\r
+            If that fails then the string is resolved as a DNS hostname.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)"/>\r
+            method.\r
+            </exception>\r
+        </member>\r
+        <member name="F:log4net.Util.TypeConverters.IPAddressConverter.validIpAddressChars">\r
+            <summary>\r
+            Valid characters in an IPv4 or IPv6 address string. (Does not support subnets)\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.PatternLayoutConverter">\r
+            <summary>\r
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Supports conversion from string to <see cref="T:log4net.Layout.PatternLayout"/> type.\r
+            </para>\r
+            <para>\r
+            The string is used as the <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/> \r
+            of the <see cref="T:log4net.Layout.PatternLayout"/>.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="sourceType"/> is\r
+            the <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.PatternLayoutConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Overrides the ConvertFrom method of IConvertFrom.\r
+            </summary>\r
+            <param name="source">the object to convert to a PatternLayout</param>\r
+            <returns>the PatternLayout</returns>\r
+            <remarks>\r
+            <para>\r
+            Creates and returns a new <see cref="T:log4net.Layout.PatternLayout"/> using\r
+            the <paramref name="source"/> <see cref="T:System.String"/> as the\r
+            <see cref="P:log4net.Layout.PatternLayout.ConversionPattern"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)"/>\r
+            method.\r
+            </exception>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.PatternStringConverter">\r
+            <summary>\r
+            Convert between string and <see cref="T:log4net.Util.PatternString"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Supports conversion from string to <see cref="T:log4net.Util.PatternString"/> type, \r
+            and from a <see cref="T:log4net.Util.PatternString"/> type to a string.\r
+            </para>\r
+            <para>\r
+            The string is used as the <see cref="P:log4net.Util.PatternString.ConversionPattern"/> \r
+            of the <see cref="T:log4net.Util.PatternString"/>.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)">\r
+            <summary>\r
+            Can the target type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="targetType">A <see cref="T:System.Type"/> that represents the type you want to convert to</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="targetType"/> is\r
+            assignable from a <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertTo(System.Object,System.Type)">\r
+            <summary>\r
+            Converts the given value object to the specified type, using the arguments\r
+            </summary>\r
+            <param name="source">the object to convert</param>\r
+            <param name="targetType">The Type to convert the value parameter to</param>\r
+            <returns>the converted object</returns>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:PatternString.Format()"/> method to convert the\r
+            <see cref="T:log4net.Util.PatternString"/> argument to a <see cref="T:System.String"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            <paramref name="targetType"/>. To check for this condition use the \r
+            <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertTo(System.Type)"/> method.\r
+            </exception>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="sourceType"/> is\r
+            the <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.PatternStringConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Overrides the ConvertFrom method of IConvertFrom.\r
+            </summary>\r
+            <param name="source">the object to convert to a PatternString</param>\r
+            <returns>the PatternString</returns>\r
+            <remarks>\r
+            <para>\r
+            Creates and returns a new <see cref="T:log4net.Util.PatternString"/> using\r
+            the <paramref name="source"/> <see cref="T:System.String"/> as the\r
+            <see cref="P:log4net.Util.PatternString.ConversionPattern"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternStringConverter.CanConvertFrom(System.Type)"/>\r
+            method.\r
+            </exception>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.TypeConverter">\r
+            <summary>\r
+            Supports conversion from string to <see cref="T:System.Type"/> type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Supports conversion from string to <see cref="T:System.Type"/> type.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="T:log4net.Util.TypeConverters.ConverterRegistry"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertFrom"/>\r
+            <seealso cref="T:log4net.Util.TypeConverters.IConvertTo"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)">\r
+            <summary>\r
+            Can the source type be converted to the type supported by this object\r
+            </summary>\r
+            <param name="sourceType">the type to convert</param>\r
+            <returns>true if the conversion is possible</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns <c>true</c> if the <paramref name="sourceType"/> is\r
+            the <see cref="T:System.String"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.TypeConverter.ConvertFrom(System.Object)">\r
+            <summary>\r
+            Overrides the ConvertFrom method of IConvertFrom.\r
+            </summary>\r
+            <param name="source">the object to convert to a Type</param>\r
+            <returns>the Type</returns>\r
+            <remarks>\r
+            <para>\r
+            Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the\r
+            <see cref="T:System.String"/> argument to a <see cref="T:System.Type"/>.\r
+            Additional effort is made to locate partially specified types\r
+            by searching the loaded assemblies.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">\r
+            The <paramref name="source"/> object cannot be converted to the\r
+            target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)"/>\r
+            method.\r
+            </exception>\r
+        </member>\r
+        <member name="T:log4net.Util.TypeConverters.TypeConverterAttribute">\r
+            <summary>\r
+            Attribute used to associate a type converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Class and Interface level attribute that specifies a type converter\r
+            to use with the associated type.\r
+            </para>\r
+            <para>\r
+            To associate a type converter with a target type apply a\r
+            <c>TypeConverterAttribute</c> to the target type. Specify the\r
+            type of the type converter on the attribute.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Util.TypeConverters.TypeConverterAttribute.m_typeName">\r
+            <summary>\r
+            The string type name of the type converter\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.String)">\r
+            <summary>\r
+            Create a new type converter attribute for the specified type name\r
+            </summary>\r
+            <param name="typeName">The string type name of the type converter</param>\r
+            <remarks>\r
+            <para>\r
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> \r
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TypeConverters.TypeConverterAttribute.#ctor(System.Type)">\r
+            <summary>\r
+            Create a new type converter attribute for the specified type\r
+            </summary>\r
+            <param name="converterType">The type of the type converter</param>\r
+            <remarks>\r
+            <para>\r
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> \r
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.TypeConverters.TypeConverterAttribute.ConverterTypeName">\r
+            <summary>\r
+            The string type name of the type converter \r
+            </summary>\r
+            <value>\r
+            The string type name of the type converter \r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The type specified must implement the <see cref="T:log4net.Util.TypeConverters.IConvertFrom"/> \r
+            or the <see cref="T:log4net.Util.TypeConverters.IConvertTo"/> interfaces.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.AppenderAttachedImpl">\r
+            <summary>\r
+            A straightforward implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is the default implementation of the <see cref="T:log4net.Core.IAppenderAttachable"/>\r
+            interface. Implementors of the <see cref="T:log4net.Core.IAppenderAttachable"/> interface\r
+            should aggregate an instance of this type.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.AppenderAttachedImpl"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Append on on all attached appenders.\r
+            </summary>\r
+            <param name="loggingEvent">The event being logged.</param>\r
+            <returns>The number of appenders called.</returns>\r
+            <remarks>\r
+            <para>\r
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all \r
+            attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.AppendLoopOnAppenders(log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Append on on all attached appenders.\r
+            </summary>\r
+            <param name="loggingEvents">The array of events being logged.</param>\r
+            <returns>The number of appenders called.</returns>\r
+            <remarks>\r
+            <para>\r
+            Calls the <see cref="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)"/> method on all \r
+            attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.CallAppend(log4net.Appender.IAppender,log4net.Core.LoggingEvent[])">\r
+            <summary>\r
+            Calls the DoAppende method on the <see cref="T:log4net.Appender.IAppender"/> with \r
+            the <see cref="T:log4net.Core.LoggingEvent"/> objects supplied.\r
+            </summary>\r
+            <param name="appender">The appender</param>\r
+            <param name="loggingEvents">The events</param>\r
+            <remarks>\r
+            <para>\r
+            If the <paramref name="appender"/> supports the <see cref="T:log4net.Appender.IBulkAppender"/>\r
+            interface then the <paramref name="loggingEvents"/> will be passed \r
+            through using that interface. Otherwise the <see cref="T:log4net.Core.LoggingEvent"/>\r
+            objects in the array will be passed one at a time.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.AddAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Attaches an appender.\r
+            </summary>\r
+            <param name="newAppender">The appender to add.</param>\r
+            <remarks>\r
+            <para>\r
+            If the appender is already in the list it won't be added again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.GetAppender(System.String)">\r
+            <summary>\r
+            Gets an attached appender with the specified name.\r
+            </summary>\r
+            <param name="name">The name of the appender to get.</param>\r
+            <returns>\r
+            The appender with the name specified, or <c>null</c> if no appender with the\r
+            specified name is found.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Lookup an attached appender by name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAllAppenders">\r
+            <summary>\r
+            Removes all attached appenders.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Removes and closes all attached appenders\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(log4net.Appender.IAppender)">\r
+            <summary>\r
+            Removes the specified appender from the list of attached appenders.\r
+            </summary>\r
+            <param name="appender">The appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            <para>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.AppenderAttachedImpl.RemoveAppender(System.String)">\r
+            <summary>\r
+            Removes the appender with the specified name from the list of appenders.\r
+            </summary>\r
+            <param name="name">The name of the appender to remove.</param>\r
+            <returns>The appender removed from the list</returns>\r
+            <remarks>\r
+            <para>\r
+            The appender removed is not closed.\r
+            If you are discarding the appender you must call\r
+            <see cref="M:log4net.Appender.IAppender.Close"/> on the appender removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderList">\r
+            <summary>\r
+            List of appenders\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.AppenderAttachedImpl.m_appenderArray">\r
+            <summary>\r
+            Array of appenders, used to cache the m_appenderList\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.AppenderAttachedImpl.declaringType">\r
+            <summary>\r
+            The fully qualified type of the AppenderAttachedImpl class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.AppenderAttachedImpl.Appenders">\r
+            <summary>\r
+            Gets all attached appenders.\r
+            </summary>\r
+            <returns>\r
+            A collection of attached appenders, or <c>null</c> if there\r
+            are no attached appenders.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            The read only collection of all currently attached appenders.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.CompositeProperties">\r
+            <summary>\r
+            This class aggregates several PropertiesDictionary collections together.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Provides a dictionary style lookup over an ordered list of\r
+            <see cref="T:log4net.Util.PropertiesDictionary"/> collections.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.CompositeProperties.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.CompositeProperties"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CompositeProperties.Add(log4net.Util.ReadOnlyPropertiesDictionary)">\r
+            <summary>\r
+            Add a Properties Dictionary to this composite collection\r
+            </summary>\r
+            <param name="properties">the properties to add</param>\r
+            <remarks>\r
+            <para>\r
+            Properties dictionaries added first take precedence over dictionaries added\r
+            later.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CompositeProperties.Flatten">\r
+            <summary>\r
+            Flatten this composite collection into a single properties dictionary\r
+            </summary>\r
+            <returns>the flattened dictionary</returns>\r
+            <remarks>\r
+            <para>\r
+            Reduces the collection of ordered dictionaries to a single dictionary\r
+            containing the resultant values for the keys.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.CompositeProperties.Item(System.String)">\r
+            <summary>\r
+            Gets the value of a property\r
+            </summary>\r
+            <value>\r
+            The value for the property with the specified key\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Looks up the value for the <paramref name="key"/> specified.\r
+            The <see cref="T:log4net.Util.PropertiesDictionary"/> collections are searched\r
+            in the order in which they were added to this collection. The value\r
+            returned is the value held by the first collection that contains\r
+            the specified key.\r
+            </para>\r
+            <para>\r
+            If none of the collections contain the specified key then\r
+            <c>null</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ContextPropertiesBase">\r
+            <summary>\r
+            Base class for Context Properties implementations\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class defines a basic property get set accessor\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="P:log4net.Util.ContextPropertiesBase.Item(System.String)">\r
+            <summary>\r
+            Gets or sets the value of a property\r
+            </summary>\r
+            <value>\r
+            The value for the property with the specified key\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the value of a property\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ConverterInfo">\r
+            <summary>\r
+            Wrapper class used to map converter names to converter types\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Pattern converter info class used during configuration by custom\r
+            PatternString and PatternLayer converters.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ConverterInfo.#ctor">\r
+            <summary>\r
+            default constructor\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ConverterInfo.AddProperty(log4net.Util.PropertyEntry)">\r
+            <summary>\r
+            \r
+            </summary>\r
+            <param name="entry"></param>\r
+        </member>\r
+        <member name="P:log4net.Util.ConverterInfo.Name">\r
+            <summary>\r
+            Gets or sets the name of the conversion pattern\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The name of the pattern in the format string\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ConverterInfo.Type">\r
+            <summary>\r
+            Gets or sets the type of the converter\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The value specified must extend the \r
+            <see cref="T:log4net.Util.PatternConverter"/> type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ConverterInfo.Properties">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.CountingQuietTextWriter">\r
+            <summary>\r
+            Subclass of <see cref="T:log4net.Util.QuietTextWriter"/> that maintains a count of \r
+            the number of bytes written.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This writer counts the number of bytes written.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Util.QuietTextWriter">\r
+            <summary>\r
+            <see cref="T:System.IO.TextWriter"/> that does not leak exceptions\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <see cref="T:log4net.Util.QuietTextWriter"/> does not throw exceptions when things go wrong. \r
+            Instead, it delegates error handling to its <see cref="T:log4net.Core.IErrorHandler"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Util.TextWriterAdapter">\r
+            <summary>\r
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all\r
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Adapter that extends <see cref="T:System.IO.TextWriter"/> and forwards all\r
+            messages to an instance of <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.TextWriterAdapter.m_writer">\r
+            <summary>\r
+            The writer to forward messages to\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.#ctor(System.IO.TextWriter)">\r
+            <summary>\r
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all\r
+            messages to a <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to forward to</param>\r
+            <remarks>\r
+            <para>\r
+            Create an instance of <see cref="T:log4net.Util.TextWriterAdapter"/> that forwards all\r
+            messages to a <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.Close">\r
+            <summary>\r
+            Closes the writer and releases any system resources associated with the writer\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.Dispose(System.Boolean)">\r
+            <summary>\r
+            Dispose this writer\r
+            </summary>\r
+            <param name="disposing">flag indicating if we are being disposed</param>\r
+            <remarks>\r
+            <para>\r
+            Dispose this writer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.Flush">\r
+            <summary>\r
+            Flushes any buffered output\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clears all buffers for the writer and causes any buffered data to be written \r
+            to the underlying device\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char)">\r
+            <summary>\r
+            Writes a character to the wrapped TextWriter\r
+            </summary>\r
+            <param name="value">the value to write to the TextWriter</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a character to the wrapped TextWriter\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.Char[],System.Int32,System.Int32)">\r
+            <summary>\r
+            Writes a character buffer to the wrapped TextWriter\r
+            </summary>\r
+            <param name="buffer">the data buffer</param>\r
+            <param name="index">the start index</param>\r
+            <param name="count">the number of characters to write</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a character buffer to the wrapped TextWriter\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.TextWriterAdapter.Write(System.String)">\r
+            <summary>\r
+            Writes a string to the wrapped TextWriter\r
+            </summary>\r
+            <param name="value">the value to write to the TextWriter</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a string to the wrapped TextWriter\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.TextWriterAdapter.Writer">\r
+            <summary>\r
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </summary>\r
+            <value>\r
+            The underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the underlying <see cref="T:System.IO.TextWriter"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.TextWriterAdapter.Encoding">\r
+            <summary>\r
+            The Encoding in which the output is written\r
+            </summary>\r
+            <value>\r
+            The <see cref="P:log4net.Util.TextWriterAdapter.Encoding"/>\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The Encoding in which the output is written\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.TextWriterAdapter.FormatProvider">\r
+            <summary>\r
+            Gets an object that controls formatting\r
+            </summary>\r
+            <value>\r
+            The format provider\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets an object that controls formatting\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.TextWriterAdapter.NewLine">\r
+            <summary>\r
+            Gets or sets the line terminator string used by the TextWriter\r
+            </summary>\r
+            <value>\r
+            The line terminator to use\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the line terminator string used by the TextWriter\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.QuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="writer">the writer to actually write to</param>\r
+            <param name="errorHandler">the error handler to report error to</param>\r
+            <remarks>\r
+            <para>\r
+            Create a new QuietTextWriter using a writer and error handler\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char)">\r
+            <summary>\r
+            Writes a character to the underlying writer\r
+            </summary>\r
+            <param name="value">the char to write</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a character to the underlying writer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">\r
+            <summary>\r
+            Writes a buffer to the underlying writer\r
+            </summary>\r
+            <param name="buffer">the buffer to write</param>\r
+            <param name="index">the start index to write from</param>\r
+            <param name="count">the number of characters to write</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a buffer to the underlying writer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.QuietTextWriter.Write(System.String)">\r
+            <summary>\r
+            Writes a string to the output.\r
+            </summary>\r
+            <param name="value">The string data to write to the output.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes a string to the output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.QuietTextWriter.Close">\r
+            <summary>\r
+            Closes the underlying output writer.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Closes the underlying output writer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.QuietTextWriter.m_errorHandler">\r
+            <summary>\r
+            The error handler instance to pass all errors to\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.QuietTextWriter.m_closed">\r
+            <summary>\r
+            Flag to indicate if this writer is closed\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.QuietTextWriter.ErrorHandler">\r
+            <summary>\r
+            Gets or sets the error handler that all errors are passed to.\r
+            </summary>\r
+            <value>\r
+            The error handler that all errors are passed to.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the error handler that all errors are passed to.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.QuietTextWriter.Closed">\r
+            <summary>\r
+            Gets a value indicating whether this writer is closed.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if this writer is closed, otherwise <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets a value indicating whether this writer is closed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CountingQuietTextWriter.#ctor(System.IO.TextWriter,log4net.Core.IErrorHandler)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="writer">The <see cref="T:System.IO.TextWriter"/> to actually write to.</param>\r
+            <param name="errorHandler">The <see cref="T:log4net.Core.IErrorHandler"/> to report errors to.</param>\r
+            <remarks>\r
+            <para>\r
+            Creates a new instance of the <see cref="T:log4net.Util.CountingQuietTextWriter"/> class \r
+            with the specified <see cref="T:System.IO.TextWriter"/> and <see cref="T:log4net.Core.IErrorHandler"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char)">\r
+            <summary>\r
+            Writes a character to the underlying writer and counts the number of bytes written.\r
+            </summary>\r
+            <param name="value">the char to write</param>\r
+            <remarks>\r
+            <para>\r
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts\r
+            the number of bytes written.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.Char[],System.Int32,System.Int32)">\r
+            <summary>\r
+            Writes a buffer to the underlying writer and counts the number of bytes written.\r
+            </summary>\r
+            <param name="buffer">the buffer to write</param>\r
+            <param name="index">the start index to write from</param>\r
+            <param name="count">the number of characters to write</param>\r
+            <remarks>\r
+            <para>\r
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts\r
+            the number of bytes written.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CountingQuietTextWriter.Write(System.String)">\r
+            <summary>\r
+            Writes a string to the output and counts the number of bytes written.\r
+            </summary>\r
+            <param name="str">The string data to write to the output.</param>\r
+            <remarks>\r
+            <para>\r
+            Overrides implementation of <see cref="T:log4net.Util.QuietTextWriter"/>. Counts\r
+            the number of bytes written.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.CountingQuietTextWriter.m_countBytes">\r
+            <summary>\r
+            Total number of bytes written.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.CountingQuietTextWriter.Count">\r
+            <summary>\r
+            Gets or sets the total number of bytes written.\r
+            </summary>\r
+            <value>\r
+            The total number of bytes written.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the total number of bytes written.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.CyclicBuffer">\r
+            <summary>\r
+            A fixed size rolling buffer of logging events.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            An array backed fixed size leaky bucket.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.CyclicBuffer.#ctor(System.Int32)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="maxSize">The maximum number of logging events in the buffer.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.CyclicBuffer"/> class with \r
+            the specified maximum number of buffered logging events.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="maxSize"/> argument is not a positive integer.</exception>\r
+        </member>\r
+        <member name="M:log4net.Util.CyclicBuffer.Append(log4net.Core.LoggingEvent)">\r
+            <summary>\r
+            Appends a <paramref name="loggingEvent"/> to the buffer.\r
+            </summary>\r
+            <param name="loggingEvent">The event to append to the buffer.</param>\r
+            <returns>The event discarded from the buffer, if the buffer is full, otherwise <c>null</c>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Append an event to the buffer. If the buffer still contains free space then\r
+            <c>null</c> is returned. If the buffer is full then an event will be dropped\r
+            to make space for the new event, the event dropped is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CyclicBuffer.PopOldest">\r
+            <summary>\r
+            Get and remove the oldest event in the buffer.\r
+            </summary>\r
+            <returns>The oldest logging event in the buffer</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the oldest (first) logging event in the buffer and removes it \r
+            from the buffer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CyclicBuffer.PopAll">\r
+            <summary>\r
+            Pops all the logging events from the buffer into an array.\r
+            </summary>\r
+            <returns>An array of all the logging events in the buffer.</returns>\r
+            <remarks>\r
+            <para>\r
+            Get all the events in the buffer and clear the buffer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.CyclicBuffer.Clear">\r
+            <summary>\r
+            Clear the buffer\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clear the buffer of all events. The events in the buffer are lost.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.CyclicBuffer.Item(System.Int32)">\r
+            <summary>\r
+            Gets the <paramref name="i"/>th oldest event currently in the buffer.\r
+            </summary>\r
+            <value>The <paramref name="i"/>th oldest event currently in the buffer.</value>\r
+            <remarks>\r
+            <para>\r
+            If <paramref name="i"/> is outside the range 0 to the number of events\r
+            currently in the buffer, then <c>null</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.CyclicBuffer.MaxSize">\r
+            <summary>\r
+            Gets the maximum size of the buffer.\r
+            </summary>\r
+            <value>The maximum size of the buffer.</value>\r
+            <remarks>\r
+            <para>\r
+            Gets the maximum size of the buffer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.CyclicBuffer.Length">\r
+            <summary>\r
+            Gets the number of logging events in the buffer.\r
+            </summary>\r
+            <value>The number of logging events in the buffer.</value>\r
+            <remarks>\r
+            <para>\r
+            This number is guaranteed to be in the range 0 to <see cref="P:log4net.Util.CyclicBuffer.MaxSize"/>\r
+            (inclusive).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.EmptyCollection">\r
+            <summary>\r
+            An always empty <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A singleton implementation of the <see cref="T:System.Collections.ICollection"/>\r
+            interface that always represents an empty collection.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyCollection.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyCollection"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to enforce the singleton pattern.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyCollection.CopyTo(System.Array,System.Int32)">\r
+            <summary>\r
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an \r
+            <see cref="T:System.Array"/>, starting at a particular Array index.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> \r
+            that is the destination of the elements copied from \r
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based \r
+            indexing.</param>\r
+            <param name="index">The zero-based index in array at which \r
+            copying begins.</param>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty no values are copied into the array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyCollection.GetEnumerator">\r
+            <summary>\r
+            Returns an enumerator that can iterate through a collection.\r
+            </summary>\r
+            <returns>\r
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to \r
+            iterate through the collection.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.EmptyCollection.s_instance">\r
+            <summary>\r
+            The singleton instance of the empty collection.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyCollection.Instance">\r
+            <summary>\r
+            Gets the singleton instance of the empty collection.\r
+            </summary>\r
+            <returns>The singleton instance of the empty collection.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the singleton instance of the empty collection.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyCollection.IsSynchronized">\r
+            <summary>\r
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).\r
+            </summary>\r
+            <value>\r
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <c>true</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyCollection.Count">\r
+            <summary>\r
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <value>\r
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty the <see cref="P:log4net.Util.EmptyCollection.Count"/> is always <c>0</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyCollection.SyncRoot">\r
+            <summary>\r
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <value>\r
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty and thread safe and synchronized this instance is also\r
+            the <see cref="P:log4net.Util.EmptyCollection.SyncRoot"/> object.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.EmptyDictionary">\r
+            <summary>\r
+            An always empty <see cref="T:System.Collections.IDictionary"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A singleton implementation of the <see cref="T:System.Collections.IDictionary"/>\r
+            interface that always represents an empty collection.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.EmptyDictionary"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to enforce the singleton pattern.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.CopyTo(System.Array,System.Int32)">\r
+            <summary>\r
+            Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an \r
+            <see cref="T:System.Array"/>, starting at a particular Array index.\r
+            </summary>\r
+            <param name="array">The one-dimensional <see cref="T:System.Array"/> \r
+            that is the destination of the elements copied from \r
+            <see cref="T:System.Collections.ICollection"/>. The Array must have zero-based \r
+            indexing.</param>\r
+            <param name="index">The zero-based index in array at which \r
+            copying begins.</param>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty no values are copied into the array.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.System#Collections#IEnumerable#GetEnumerator">\r
+            <summary>\r
+            Returns an enumerator that can iterate through a collection.\r
+            </summary>\r
+            <returns>\r
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to \r
+            iterate through the collection.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.Add(System.Object,System.Object)">\r
+            <summary>\r
+            Adds an element with the provided key and value to the \r
+            <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </summary>\r
+            <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>\r
+            <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty no new values can be added. A <see cref="T:System.InvalidOperationException"/>\r
+            is thrown if this method is called.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.Clear">\r
+            <summary>\r
+            Removes all elements from the <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>\r
+            is thrown if this method is called.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.Contains(System.Object)">\r
+            <summary>\r
+            Determines whether the <see cref="T:log4net.Util.EmptyDictionary"/> contains an element \r
+            with the specified key.\r
+            </summary>\r
+            <param name="key">The key to locate in the <see cref="T:log4net.Util.EmptyDictionary"/>.</param>\r
+            <returns><c>false</c></returns>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty the <see cref="M:log4net.Util.EmptyDictionary.Contains(System.Object)"/> method always returns <c>false</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.GetEnumerator">\r
+            <summary>\r
+            Returns an enumerator that can iterate through a collection.\r
+            </summary>\r
+            <returns>\r
+            An <see cref="T:System.Collections.IEnumerator"/> that can be used to \r
+            iterate through the collection.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty a <see cref="T:log4net.Util.NullEnumerator"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.EmptyDictionary.Remove(System.Object)">\r
+            <summary>\r
+            Removes the element with the specified key from the <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </summary>\r
+            <param name="key">The key of the element to remove.</param>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty no values can be removed. A <see cref="T:System.InvalidOperationException"/>\r
+            is thrown if this method is called.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>\r
+        </member>\r
+        <member name="F:log4net.Util.EmptyDictionary.s_instance">\r
+            <summary>\r
+            The singleton instance of the empty dictionary.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.Instance">\r
+            <summary>\r
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </summary>\r
+            <returns>The singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the singleton instance of the <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.IsSynchronized">\r
+            <summary>\r
+            Gets a value indicating if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe).\r
+            </summary>\r
+            <value>\r
+            <b>true</b> if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread-safe); otherwise, <b>false</b>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            For the <see cref="T:log4net.Util.EmptyCollection"/> this property is always <b>true</b>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.Count">\r
+            <summary>\r
+            Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>\r
+            </summary>\r
+            <value>\r
+            The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty the <see cref="P:log4net.Util.EmptyDictionary.Count"/> is always <c>0</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.SyncRoot">\r
+            <summary>\r
+            Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.\r
+            </summary>\r
+            <value>\r
+            An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty and thread safe and synchronized this instance is also\r
+            the <see cref="P:log4net.Util.EmptyDictionary.SyncRoot"/> object.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.IsFixedSize">\r
+            <summary>\r
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> has a fixed size.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsFixedSize"/> always returns <c>true</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.IsReadOnly">\r
+            <summary>\r
+            Gets a value indicating whether the <see cref="T:log4net.Util.EmptyDictionary"/> is read-only.\r
+            </summary>\r
+            <value><c>true</c></value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty <see cref="P:log4net.Util.EmptyDictionary.IsReadOnly"/> always returns <c>true</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.Keys">\r
+            <summary>\r
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </summary>\r
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the keys of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.Values">\r
+            <summary>\r
+            Gets an <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.\r
+            </summary>\r
+            <value>An <see cref="T:System.Collections.ICollection"/> containing the values of the <see cref="T:log4net.Util.EmptyDictionary"/>.</value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty a <see cref="T:log4net.Util.EmptyCollection"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.EmptyDictionary.Item(System.Object)">\r
+            <summary>\r
+            Gets or sets the element with the specified key.\r
+            </summary>\r
+            <param name="key">The key of the element to get or set.</param>\r
+            <value><c>null</c></value>\r
+            <remarks>\r
+            <para>\r
+            As the collection is empty no values can be looked up or stored. \r
+            If the index getter is called then <c>null</c> is returned.\r
+            A <see cref="T:System.InvalidOperationException"/> is thrown if the setter is called.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">This dictionary is always empty and cannot be modified.</exception>\r
+        </member>\r
+        <member name="T:log4net.Util.FormattingInfo">\r
+            <summary>\r
+            Contain the information obtained when parsing formatting modifiers \r
+            in conversion modifiers.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Holds the formatting information extracted from the format string by\r
+            the <see cref="T:log4net.Util.PatternParser"/>. This is used by the <see cref="T:log4net.Util.PatternConverter"/>\r
+            objects when rendering the output.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.FormattingInfo.#ctor">\r
+            <summary>\r
+            Defaut Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.FormattingInfo.#ctor(System.Int32,System.Int32,System.Boolean)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.FormattingInfo"/> class\r
+            with the specified parameters.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.FormattingInfo.Min">\r
+            <summary>\r
+            Gets or sets the minimum value.\r
+            </summary>\r
+            <value>\r
+            The minimum value.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the minimum value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.FormattingInfo.Max">\r
+            <summary>\r
+            Gets or sets the maximum value.\r
+            </summary>\r
+            <value>\r
+            The maximum value.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the maximum value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.FormattingInfo.LeftAlign">\r
+            <summary>\r
+            Gets or sets a flag indicating whether left align is enabled\r
+            or not.\r
+            </summary>\r
+            <value>\r
+            A flag indicating whether left align is enabled or not.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets a flag indicating whether left align is enabled or not.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.GlobalContextProperties">\r
+            <summary>\r
+            Implementation of Properties collection for the <see cref="T:log4net.GlobalContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class implements a properties collection that is thread safe and supports both\r
+            storing properties and capturing a read only copy of the current propertied.\r
+            </para>\r
+            <para>\r
+            This class is optimized to the scenario where the properties are read frequently\r
+            and are modified infrequently.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.GlobalContextProperties.m_readOnlyProperties">\r
+            <summary>\r
+            The read only copy of the properties.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This variable is declared <c>volatile</c> to prevent the compiler and JIT from\r
+            reordering reads and writes of this thread performed on different threads.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.GlobalContextProperties.m_syncRoot">\r
+            <summary>\r
+            Lock object used to synchronize updates within this instance\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.GlobalContextProperties.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.GlobalContextProperties"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.GlobalContextProperties.Remove(System.String)">\r
+            <summary>\r
+            Remove a property from the global context\r
+            </summary>\r
+            <param name="key">the key for the entry to remove</param>\r
+            <remarks>\r
+            <para>\r
+            Removing an entry from the global context properties is relatively expensive compared\r
+            with reading a value. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.GlobalContextProperties.Clear">\r
+            <summary>\r
+            Clear the global context properties\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.GlobalContextProperties.GetReadOnlyProperties">\r
+            <summary>\r
+            Get a readonly immutable copy of the properties\r
+            </summary>\r
+            <returns>the current global context properties</returns>\r
+            <remarks>\r
+            <para>\r
+            This implementation is fast because the GlobalContextProperties class\r
+            stores a readonly copy of the properties.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.GlobalContextProperties.Item(System.String)">\r
+            <summary>\r
+            Gets or sets the value of a property\r
+            </summary>\r
+            <value>\r
+            The value for the property with the specified key\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Reading the value for a key is faster than setting the value.\r
+            When the value is written a new read only copy of \r
+            the properties is created.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ILogExtensions">\r
+            <summary>\r
+            The static class ILogExtensions contains a set of widely used\r
+            methods that ease the interaction with the ILog interface implementations.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class contains methods for logging at different levels and checks the\r
+            properties for determining if those logging levels are enabled in the current\r
+            configuration.\r
+            </para>\r
+            </remarks>\r
+            <example>Simple example of logging messages\r
+            <code lang="C#">\r
+            using log4net.Util;\r
+            \r
+            ILog log = LogManager.GetLogger("application-log");\r
+            \r
+            log.InfoExt("Application Start");\r
+            log.DebugExt("This is a debug message");\r
+            </code>\r
+            </example>\r
+        </member>\r
+        <member name="F:log4net.Util.ILogExtensions.declaringType">\r
+            <summary>\r
+            The fully qualified type of the Logger class.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object})">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>INFO</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts \r
+            the message object (retrieved by invocation of the provided callback) to a \r
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.\r
+            It then proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Func{System.Object},System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.</overloads> //TODO\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>INFO</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsDebugEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation. If this logger is <c>INFO</c> enabled, then it converts \r
+            the message object (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Debug"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.DebugFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Debug"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.DebugExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Debug(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsDebugEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object})">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>INFO</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation.  If this logger is <c>INFO</c> enabled, then it converts \r
+            the message object (retrieved by invocation of the provided callback) to a \r
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.\r
+            It then proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Func{System.Object},System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.</overloads> //TODO\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>INFO</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsInfoEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation. If this logger is <c>INFO</c> enabled, then it converts \r
+            the message object (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Info"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.InfoFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Info"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.InfoExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Info(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsInfoEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object})">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>WARN</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation.  If this logger is <c>WARN</c> enabled, then it converts \r
+            the message object (retrieved by invocation of the provided callback) to a \r
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.\r
+            It then proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Func{System.Object},System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.</overloads> //TODO\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>WARN</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsWarnEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation. If this logger is <c>WARN</c> enabled, then it converts \r
+            the message object (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Warn"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.WarnFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Warn"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.WarnExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Warn(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsWarnEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object})">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>ERROR</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation.  If this logger is <c>ERROR</c> enabled, then it converts \r
+            the message object (retrieved by invocation of the provided callback) to a \r
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.\r
+            It then proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Func{System.Object},System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.</overloads> //TODO\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>ERROR</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsErrorEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation. If this logger is <c>ERROR</c> enabled, then it converts \r
+            the message object (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Error"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.ErrorFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Error"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.ErrorExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Error(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsErrorEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object})">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>FATAL</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation.  If this logger is <c>FATAL</c> enabled, then it converts \r
+            the message object (retrieved by invocation of the provided callback) to a \r
+            string by invoking the appropriate <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>.\r
+            It then proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Func{System.Object},System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="callback">The lambda expression that gets the object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)">\r
+            <overloads>Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.</overloads> //TODO\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <remarks>\r
+            <para>\r
+            This method first checks if this logger is <c>FATAL</c>\r
+            enabled by reading the value <seealso cref="P:log4net.ILog.IsFatalEnabled"/> property.\r
+            This check happens always and does not depend on the <seealso cref="T:log4net.ILog"/>\r
+            implementation. If this logger is <c>FATAL</c> enabled, then it converts \r
+            the message object (passed as parameter) to a string by invoking the appropriate\r
+            <see cref="T:log4net.ObjectRenderer.IObjectRenderer"/>. It then \r
+            proceeds to call all the registered appenders in this logger \r
+            and also higher in the hierarchy depending on the value of \r
+            the additivity flag.\r
+            </para>\r
+            <para><b>WARNING</b> Note that passing an <see cref="T:System.Exception"/> \r
+            to this method will print the name of the <see cref="T:System.Exception"/> \r
+            but no stack trace. To print a stack trace use the \r
+            <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/> form instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)">\r
+            <summary>\r
+            Log a message object with the <see cref="F:log4net.Core.Level.Fatal"/> level including\r
+            the stack trace of the <see cref="T:System.Exception"/> passed\r
+            as a parameter.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="message">The message object to log.</param>\r
+            <param name="exception">The exception to log, including its stack trace.</param>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object)"/> form for more detailed information.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information</param>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="args">An Object array containing zero or more objects to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="M:log4net.Util.ILogExtensions.FatalFormatExt(log4net.ILog,System.String,System.Object,System.Object,System.Object)">\r
+            <summary>\r
+            Logs a formatted message string with the <see cref="F:log4net.Core.Level.Fatal"/> level.\r
+            </summary>\r
+            <param name="logger">The logger on which the message is logged.</param>\r
+            <param name="format">A String containing zero or more format items</param>\r
+            <param name="arg0">An Object to format</param>\r
+            <param name="arg1">An Object to format</param>\r
+            <param name="arg2">An Object to format</param>\r
+            <remarks>\r
+            <para>\r
+            The message is formatted using the <c>String.Format</c> method. See\r
+            <see cref="M:System.String.Format(System.String,System.Object[])"/> for details of the syntax of the format string and the behavior\r
+            of the formatting.\r
+            </para>\r
+            <para>\r
+            This method does not take an <see cref="T:System.Exception"/> object to include in the\r
+            log event. To pass an <see cref="T:System.Exception"/> use one of the <see cref="M:log4net.Util.ILogExtensions.FatalExt(log4net.ILog,System.Object,System.Exception)"/>\r
+            methods instead.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.ILog.Fatal(System.Object)"/>\r
+            <seealso cref="P:log4net.ILog.IsFatalEnabled"/>\r
+        </member>\r
+        <member name="T:log4net.Util.LevelMapping">\r
+            <summary>\r
+            Manages a mapping from levels to <see cref="T:log4net.Util.LevelMappingEntry"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Manages an ordered mapping from <see cref="T:log4net.Core.Level"/> instances \r
+            to <see cref="T:log4net.Util.LevelMappingEntry"/> subclasses.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.LevelMapping.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initialise a new instance of <see cref="T:log4net.Util.LevelMapping"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LevelMapping.Add(log4net.Util.LevelMappingEntry)">\r
+            <summary>\r
+            Add a <see cref="T:log4net.Util.LevelMappingEntry"/> to this mapping\r
+            </summary>\r
+            <param name="entry">the entry to add</param>\r
+            <remarks>\r
+            <para>\r
+            If a <see cref="T:log4net.Util.LevelMappingEntry"/> has previously been added\r
+            for the same <see cref="T:log4net.Core.Level"/> then that entry will be \r
+            overwritten.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LevelMapping.Lookup(log4net.Core.Level)">\r
+            <summary>\r
+            Lookup the mapping for the specified level\r
+            </summary>\r
+            <param name="level">the level to lookup</param>\r
+            <returns>the <see cref="T:log4net.Util.LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>\r
+            <remarks>\r
+            <para>\r
+            Lookup the value for the specified level. Finds the nearest\r
+            mapping value for the level that is equal to or less than the\r
+            <paramref name="level"/> specified.\r
+            </para>\r
+            <para>\r
+            If no mapping could be found then <c>null</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LevelMapping.ActivateOptions">\r
+            <summary>\r
+            Initialize options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Caches the sorted list of <see cref="T:log4net.Util.LevelMappingEntry"/> in an array\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.LogicalThreadContextProperties">\r
+            <summary>\r
+            Implementation of Properties collection for the <see cref="T:log4net.LogicalThreadContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Class implements a collection of properties that is specific to each thread.\r
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.\r
+            </para>\r
+            <para>\r
+            This class stores its properties in a slot on the <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> named\r
+            <c>log4net.Util.LogicalThreadContextProperties</c>.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time \r
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the\r
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.\r
+            If the calling code does not have this permission then this context will be disabled.\r
+            It will not store any property values set on it.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.LogicalThreadContextProperties.m_disabled">\r
+            <summary>\r
+            Flag used to disable this context if we don't have permission to access the CallContext.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.LogicalThreadContextProperties.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.LogicalThreadContextProperties"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Remove(System.String)">\r
+            <summary>\r
+            Remove a property\r
+            </summary>\r
+            <param name="key">the key for the entry to remove</param>\r
+            <remarks>\r
+            <para>\r
+            Remove the value for the specified <paramref name="key"/> from the context.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogicalThreadContextProperties.Clear">\r
+            <summary>\r
+            Clear all the context properties\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clear all the context properties\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetProperties(System.Boolean)">\r
+            <summary>\r
+            Get the PropertiesDictionary stored in the LocalDataStoreSlot for this thread.\r
+            </summary>\r
+            <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>\r
+            <returns>the properties for this thread</returns>\r
+            <remarks>\r
+            <para>\r
+            The collection returned is only to be used on the calling thread. If the\r
+            caller needs to share the collection between different threads then the \r
+            caller must clone the collection before doings so.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogicalThreadContextProperties.GetCallContextData">\r
+            <summary>\r
+            Gets the call context get data.\r
+            </summary>\r
+            <returns>The peroperties dictionary stored in the call context</returns>\r
+            <remarks>\r
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.GetData(System.String)"/> has a\r
+            security link demand, therfore we must put the method call in a seperate method\r
+            that we can wrap in an exception handler.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogicalThreadContextProperties.SetCallContextData(log4net.Util.PropertiesDictionary)">\r
+            <summary>\r
+            Sets the call context data.\r
+            </summary>\r
+            <param name="properties">The properties.</param>\r
+            <remarks>\r
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> method <see cref="M:System.Runtime.Remoting.Messaging.CallContext.SetData(System.String,System.Object)"/> has a\r
+            security link demand, therfore we must put the method call in a seperate method\r
+            that we can wrap in an exception handler.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.LogicalThreadContextProperties.declaringType">\r
+            <summary>\r
+            The fully qualified type of the LogicalThreadContextProperties class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.LogicalThreadContextProperties.Item(System.String)">\r
+            <summary>\r
+            Gets or sets the value of a property\r
+            </summary>\r
+            <value>\r
+            The value for the property with the specified key\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Get or set the property value for the <paramref name="key"/> specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.LogReceivedEventHandler">\r
+            <summary>\r
+            \r
+            </summary>\r
+            <param name="source"></param>\r
+            <param name="e"></param>\r
+        </member>\r
+        <member name="T:log4net.Util.LogLog">\r
+            <summary>\r
+            Outputs log statements from within the log4net assembly.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Log4net components cannot make log4net logging calls. However, it is\r
+            sometimes useful for the user to learn about what log4net is\r
+            doing.\r
+            </para>\r
+            <para>\r
+            All log4net internal debug calls go to the standard output stream\r
+            whereas internal error messages are sent to the standard error output \r
+            stream.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.ToString">\r
+            <summary>\r
+            Formats Prefix, Source, and Message in the same format as the value\r
+            sent to Console.Out and Trace.Write.\r
+            </summary>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.#ctor(System.Type,System.String,System.String,System.Exception)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.LogLog"/> class. \r
+            </summary>\r
+            <param name="source"></param>\r
+            <param name="prefix"></param>\r
+            <param name="message"></param>\r
+            <param name="exception"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.#cctor">\r
+            <summary>\r
+            Static constructor that initializes logging by reading \r
+            settings from the application configuration file.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>log4net.Internal.Debug</c> application setting\r
+            controls internal debugging. This setting should be set\r
+            to <c>true</c> to enable debugging.\r
+            </para>\r
+            <para>\r
+            The <c>log4net.Internal.Quiet</c> application setting\r
+            suppresses all internal logging including error messages. \r
+            This setting should be set to <c>true</c> to enable message\r
+            suppression.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.OnLogReceived(System.Type,System.String,System.String,System.Exception)">\r
+            <summary>\r
+            Raises the LogReceived event when an internal messages is received.\r
+            </summary>\r
+            <param name="source"></param>\r
+            <param name="prefix"></param>\r
+            <param name="message"></param>\r
+            <param name="exception"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String)">\r
+            <summary>\r
+            Writes log4net internal debug messages to the \r
+            standard output stream.\r
+            </summary>\r
+            <param name="source"></param>\r
+            <param name="message">The message to log.</param>\r
+            <remarks>\r
+            <para>\r
+            All internal debug messages are prepended with \r
+            the string "log4net: ".\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.Debug(System.Type,System.String,System.Exception)">\r
+            <summary>\r
+            Writes log4net internal debug messages to the \r
+            standard output stream.\r
+            </summary>\r
+            <param name="source">The Type that generated this message.</param>\r
+            <param name="message">The message to log.</param>\r
+            <param name="exception">An exception to log.</param>\r
+            <remarks>\r
+            <para>\r
+            All internal debug messages are prepended with \r
+            the string "log4net: ".\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String)">\r
+            <summary>\r
+            Writes log4net internal warning messages to the \r
+            standard error stream.\r
+            </summary>\r
+            <param name="source">The Type that generated this message.</param>\r
+            <param name="message">The message to log.</param>\r
+            <remarks>\r
+            <para>\r
+            All internal warning messages are prepended with \r
+            the string "log4net:WARN ".\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.Warn(System.Type,System.String,System.Exception)">\r
+            <summary>\r
+            Writes log4net internal warning messages to the \r
+            standard error stream.\r
+            </summary>\r
+            <param name="source">The Type that generated this message.</param>\r
+            <param name="message">The message to log.</param>\r
+            <param name="exception">An exception to log.</param>\r
+            <remarks>\r
+            <para>\r
+            All internal warning messages are prepended with \r
+            the string "log4net:WARN ".\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String)">\r
+            <summary>\r
+            Writes log4net internal error messages to the \r
+            standard error stream.\r
+            </summary>\r
+            <param name="source">The Type that generated this message.</param>\r
+            <param name="message">The message to log.</param>\r
+            <remarks>\r
+            <para>\r
+            All internal error messages are prepended with \r
+            the string "log4net:ERROR ".\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.Error(System.Type,System.String,System.Exception)">\r
+            <summary>\r
+            Writes log4net internal error messages to the \r
+            standard error stream.\r
+            </summary>\r
+            <param name="source">The Type that generated this message.</param>\r
+            <param name="message">The message to log.</param>\r
+            <param name="exception">An exception to log.</param>\r
+            <remarks>\r
+            <para>\r
+            All internal debug messages are prepended with \r
+            the string "log4net:ERROR ".\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.EmitOutLine(System.String)">\r
+            <summary>\r
+            Writes output to the standard output stream.  \r
+            </summary>\r
+            <param name="message">The message to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes to both Console.Out and System.Diagnostics.Trace.\r
+            Note that the System.Diagnostics.Trace is not supported\r
+            on the Compact Framework.\r
+            </para>\r
+            <para>\r
+            If the AppDomain is not configured with a config file then\r
+            the call to System.Diagnostics.Trace may fail. This is only\r
+            an issue if you are programmatically creating your own AppDomains.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.EmitErrorLine(System.String)">\r
+            <summary>\r
+            Writes output to the standard error stream.  \r
+            </summary>\r
+            <param name="message">The message to log.</param>\r
+            <remarks>\r
+            <para>\r
+            Writes to both Console.Error and System.Diagnostics.Trace.\r
+            Note that the System.Diagnostics.Trace is not supported\r
+            on the Compact Framework.\r
+            </para>\r
+            <para>\r
+            If the AppDomain is not configured with a config file then\r
+            the call to System.Diagnostics.Trace may fail. This is only\r
+            an issue if you are programmatically creating your own AppDomains.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.LogLog.s_debugEnabled">\r
+            <summary>\r
+             Default debug level\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.LogLog.s_quietMode">\r
+            <summary>\r
+            In quietMode not even errors generate any output.\r
+            </summary>\r
+        </member>\r
+        <member name="E:log4net.Util.LogLog.LogReceived">\r
+            <summary>\r
+            The event raised when an internal message has been received.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.Source">\r
+            <summary>\r
+            The Type that generated the internal message.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.TimeStamp">\r
+            <summary>\r
+            The DateTime stamp of when the internal message was received.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.Prefix">\r
+            <summary>\r
+            A string indicating the severity of the internal message.\r
+            </summary>\r
+            <remarks>\r
+            "log4net: ", \r
+            "log4net:ERROR ", \r
+            "log4net:WARN "\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.Message">\r
+            <summary>\r
+            The internal log message.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.Exception">\r
+            <summary>\r
+            The Exception related to the message.\r
+            </summary>\r
+            <remarks>\r
+            Optional. Will be null if no Exception was passed.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.InternalDebugging">\r
+            <summary>\r
+            Gets or sets a value indicating whether log4net internal logging\r
+            is enabled or disabled.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if log4net internal logging is enabled, otherwise \r
+            <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            When set to <c>true</c>, internal debug level logging will be \r
+            displayed.\r
+            </para>\r
+            <para>\r
+            This value can be set by setting the application setting \r
+            <c>log4net.Internal.Debug</c> in the application configuration\r
+            file.\r
+            </para>\r
+            <para>\r
+            The default value is <c>false</c>, i.e. debugging is\r
+            disabled.\r
+            </para>\r
+            </remarks>\r
+            <example>\r
+            <para>\r
+            The following example enables internal debugging using the \r
+            application configuration file :\r
+            </para>\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <appSettings>\r
+                       <add key="log4net.Internal.Debug" value="true" />\r
+               </appSettings>\r
+            </configuration>\r
+            </code>\r
+            </example>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.QuietMode">\r
+            <summary>\r
+            Gets or sets a value indicating whether log4net should generate no output\r
+            from internal logging, not even for errors. \r
+            </summary>\r
+            <value>\r
+            <c>true</c> if log4net should generate no output at all from internal \r
+            logging, otherwise <c>false</c>.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            When set to <c>true</c> will cause internal logging at all levels to be \r
+            suppressed. This means that no warning or error reports will be logged. \r
+            This option overrides the <see cref="P:log4net.Util.LogLog.InternalDebugging"/> setting and \r
+            disables all debug also.\r
+            </para>\r
+            <para>This value can be set by setting the application setting\r
+            <c>log4net.Internal.Quiet</c> in the application configuration file.\r
+            </para>\r
+            <para>\r
+            The default value is <c>false</c>, i.e. internal logging is not\r
+            disabled.\r
+            </para>\r
+            </remarks>\r
+            <example>\r
+            The following example disables internal logging using the \r
+            application configuration file :\r
+            <code lang="XML" escaped="true">\r
+            <configuration>\r
+               <appSettings>\r
+                       <add key="log4net.Internal.Quiet" value="true"/>\r
+               </appSettings>\r
+            </configuration>\r
+            </code>\r
+            </example>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.EmitInternalMessages">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.IsDebugEnabled">\r
+            <summary>\r
+            Test if LogLog.Debug is enabled for output.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if Debug is enabled\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Test if LogLog.Debug is enabled for output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.IsWarnEnabled">\r
+            <summary>\r
+            Test if LogLog.Warn is enabled for output.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if Warn is enabled\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Test if LogLog.Warn is enabled for output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.IsErrorEnabled">\r
+            <summary>\r
+            Test if LogLog.Error is enabled for output.\r
+            </summary>\r
+            <value>\r
+            <c>true</c> if Error is enabled\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Test if LogLog.Error is enabled for output.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.LogLog.LogReceivedAdapter">\r
+            <summary>\r
+            Subscribes to the LogLog.LogReceived event and stores messages\r
+            to the supplied IList instance.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.#ctor(System.Collections.IList)">\r
+            <summary>\r
+            \r
+            </summary>\r
+            <param name="items"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.LogLog.LogReceivedAdapter.Dispose">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.LogLog.LogReceivedAdapter.Items">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.LogReceivedEventArgs">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.LogReceivedEventArgs.#ctor(log4net.Util.LogLog)">\r
+            <summary>\r
+            \r
+            </summary>\r
+            <param name="loglog"></param>\r
+        </member>\r
+        <member name="P:log4net.Util.LogReceivedEventArgs.LogLog">\r
+            <summary>\r
+            \r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.NativeError">\r
+            <summary>\r
+            Represents a native error code and message.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Represents a Win32 platform native error.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.NativeError.#ctor(System.Int32,System.String)">\r
+            <summary>\r
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified \r
+            error number and message.\r
+            </summary>\r
+            <param name="number">The number of the native error.</param>\r
+            <param name="message">The message of the native error.</param>\r
+            <remarks>\r
+            <para>\r
+            Create an instance of the <see cref="T:log4net.Util.NativeError"/> class with the specified \r
+            error number and message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NativeError.GetLastError">\r
+            <summary>\r
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class for the last Windows error.\r
+            </summary>\r
+            <returns>\r
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the last windows error.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            The message for the <see cref="M:System.Runtime.InteropServices.Marshal.GetLastWin32Error"/> error number is lookup up using the \r
+            native Win32 <c>FormatMessage</c> function.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NativeError.GetError(System.Int32)">\r
+            <summary>\r
+            Create a new instance of the <see cref="T:log4net.Util.NativeError"/> class.\r
+            </summary>\r
+            <param name="number">the error number for the native error</param>\r
+            <returns>\r
+            An instance of the <see cref="T:log4net.Util.NativeError"/> class for the specified \r
+            error number.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            The message for the specified error number is lookup up using the \r
+            native Win32 <c>FormatMessage</c> function.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NativeError.GetErrorMessage(System.Int32)">\r
+            <summary>\r
+            Retrieves the message corresponding with a Win32 message identifier.\r
+            </summary>\r
+            <param name="messageId">Message identifier for the requested message.</param>\r
+            <returns>\r
+            The message corresponding with the specified message identifier.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            The message will be searched for in system message-table resource(s)\r
+            using the native <c>FormatMessage</c> function.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NativeError.ToString">\r
+            <summary>\r
+            Return error information string\r
+            </summary>\r
+            <returns>error information string</returns>\r
+            <remarks>\r
+            <para>\r
+            Return error information string\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NativeError.FormatMessage(System.Int32,System.IntPtr@,System.Int32,System.Int32,System.String@,System.Int32,System.IntPtr)">\r
+            <summary>\r
+            Formats a message string.\r
+            </summary>\r
+            <param name="dwFlags">Formatting options, and how to interpret the <paramref name="lpSource" /> parameter.</param>\r
+            <param name="lpSource">Location of the message definition.</param>\r
+            <param name="dwMessageId">Message identifier for the requested message.</param>\r
+            <param name="dwLanguageId">Language identifier for the requested message.</param>\r
+            <param name="lpBuffer">If <paramref name="dwFlags" /> includes FORMAT_MESSAGE_ALLOCATE_BUFFER, the function allocates a buffer using the <c>LocalAlloc</c> function, and places the pointer to the buffer at the address specified in <paramref name="lpBuffer" />.</param>\r
+            <param name="nSize">If the FORMAT_MESSAGE_ALLOCATE_BUFFER flag is not set, this parameter specifies the maximum number of TCHARs that can be stored in the output buffer. If FORMAT_MESSAGE_ALLOCATE_BUFFER is set, this parameter specifies the minimum number of TCHARs to allocate for an output buffer.</param>\r
+            <param name="Arguments">Pointer to an array of values that are used as insert values in the formatted message.</param>\r
+            <remarks>\r
+            <para>\r
+            The function requires a message definition as input. The message definition can come from a \r
+            buffer passed into the function. It can come from a message table resource in an \r
+            already-loaded module. Or the caller can ask the function to search the system's message \r
+            table resource(s) for the message definition. The function finds the message definition \r
+            in a message table resource based on a message identifier and a language identifier. \r
+            The function copies the formatted message text to an output buffer, processing any embedded \r
+            insert sequences if requested.\r
+            </para>\r
+            <para>\r
+            To prevent the usage of unsafe code, this stub does not support inserting values in the formatted message.\r
+            </para>\r
+            </remarks>\r
+            <returns>\r
+            <para>\r
+            If the function succeeds, the return value is the number of TCHARs stored in the output \r
+            buffer, excluding the terminating null character.\r
+            </para>\r
+            <para>\r
+            If the function fails, the return value is zero. To get extended error information, \r
+            call <see cref="M:Marshal.GetLastWin32Error()" />.\r
+            </para>\r
+            </returns>\r
+        </member>\r
+        <member name="P:log4net.Util.NativeError.Number">\r
+            <summary>\r
+            Gets the number of the native error.\r
+            </summary>\r
+            <value>\r
+            The number of the native error.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the number of the native error.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.NativeError.Message">\r
+            <summary>\r
+            Gets the message of the native error.\r
+            </summary>\r
+            <value>\r
+            The message of the native error.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            </para>\r
+            Gets the message of the native error.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.NullDictionaryEnumerator">\r
+            <summary>\r
+            An always empty <see cref="T:System.Collections.IDictionaryEnumerator"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A singleton implementation of the <see cref="T:System.Collections.IDictionaryEnumerator"/> over a collection\r
+            that is empty and not modifiable.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.NullDictionaryEnumerator.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to enforce the singleton pattern.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NullDictionaryEnumerator.MoveNext">\r
+            <summary>\r
+            Test if the enumerator can advance, if so advance.\r
+            </summary>\r
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullDictionaryEnumerator"/> cannot advance.</returns>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullDictionaryEnumerator.MoveNext"/>\r
+            will always return <c>false</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NullDictionaryEnumerator.Reset">\r
+            <summary>\r
+            Resets the enumerator back to the start.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullDictionaryEnumerator.Reset"/> does nothing.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.NullDictionaryEnumerator.s_instance">\r
+            <summary>\r
+            The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Instance">\r
+            <summary>\r
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.\r
+            </summary>\r
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Current">\r
+            <summary>\r
+            Gets the current object from the enumerator.\r
+            </summary>\r
+            <remarks>\r
+            Throws an <see cref="T:System.InvalidOperationException"/> because the \r
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.\r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>\r
+            will throw an <see cref="T:System.InvalidOperationException"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> \r
+            cannot be positioned over a valid location.</exception>\r
+        </member>\r
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Key">\r
+            <summary>\r
+            Gets the current key from the enumerator.\r
+            </summary>\r
+            <remarks>\r
+            Throws an exception because the <see cref="T:log4net.Util.NullDictionaryEnumerator"/>\r
+            never has a current value.\r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Key"/>\r
+            will throw an <see cref="T:System.InvalidOperationException"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> \r
+            cannot be positioned over a valid location.</exception>\r
+        </member>\r
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Value">\r
+            <summary>\r
+            Gets the current value from the enumerator.\r
+            </summary>\r
+            <value>The current value from the enumerator.</value>\r
+            <remarks>\r
+            Throws an <see cref="T:System.InvalidOperationException"/> because the \r
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.\r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Value"/>\r
+            will throw an <see cref="T:System.InvalidOperationException"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> \r
+            cannot be positioned over a valid location.</exception>\r
+        </member>\r
+        <member name="P:log4net.Util.NullDictionaryEnumerator.Entry">\r
+            <summary>\r
+            Gets the current entry from the enumerator.\r
+            </summary>\r
+            <remarks>\r
+            Throws an <see cref="T:System.InvalidOperationException"/> because the \r
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current entry.\r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullDictionaryEnumerator.Entry"/>\r
+            will throw an <see cref="T:System.InvalidOperationException"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullDictionaryEnumerator.Current"/> \r
+            cannot be positioned over a valid location.</exception>\r
+        </member>\r
+        <member name="T:log4net.Util.NullEnumerator">\r
+            <summary>\r
+            An always empty <see cref="T:System.Collections.IEnumerator"/>.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A singleton implementation of the <see cref="T:System.Collections.IEnumerator"/> over a collection\r
+            that is empty and not modifiable.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.NullEnumerator.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.NullEnumerator"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to enforce the singleton pattern.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NullEnumerator.MoveNext">\r
+            <summary>\r
+            Test if the enumerator can advance, if so advance\r
+            </summary>\r
+            <returns><c>false</c> as the <see cref="T:log4net.Util.NullEnumerator"/> cannot advance.</returns>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="M:log4net.Util.NullEnumerator.MoveNext"/>\r
+            will always return <c>false</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NullEnumerator.Reset">\r
+            <summary>\r
+            Resets the enumerator back to the start.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection <see cref="M:log4net.Util.NullEnumerator.Reset"/> does nothing.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.NullEnumerator.s_instance">\r
+            <summary>\r
+            The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.NullEnumerator.Instance">\r
+            <summary>\r
+            Get the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.\r
+            </summary>\r
+            <returns>The singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the singleton instance of the <see cref="T:log4net.Util.NullEnumerator"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.NullEnumerator.Current">\r
+            <summary>\r
+            Gets the current object from the enumerator.\r
+            </summary>\r
+            <remarks>\r
+            Throws an <see cref="T:System.InvalidOperationException"/> because the \r
+            <see cref="T:log4net.Util.NullDictionaryEnumerator"/> never has a current value.\r
+            </remarks>\r
+            <remarks>\r
+            <para>\r
+            As the enumerator is over an empty collection its <see cref="P:log4net.Util.NullEnumerator.Current"/>\r
+            value cannot be moved over a valid position, therefore <see cref="P:log4net.Util.NullEnumerator.Current"/>\r
+            will throw an <see cref="T:System.InvalidOperationException"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.InvalidOperationException">The collection is empty and <see cref="P:log4net.Util.NullEnumerator.Current"/> \r
+            cannot be positioned over a valid location.</exception>\r
+        </member>\r
+        <member name="T:log4net.Util.NullSecurityContext">\r
+            <summary>\r
+            A SecurityContext used when a SecurityContext is not required\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Util.NullSecurityContext"/> is a no-op implementation of the\r
+            <see cref="T:log4net.Core.SecurityContext"/> base class. It is used where a <see cref="T:log4net.Core.SecurityContext"/>\r
+            is required but one has not been provided.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.NullSecurityContext.Instance">\r
+            <summary>\r
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Singleton instance of <see cref="T:log4net.Util.NullSecurityContext"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NullSecurityContext.#ctor">\r
+            <summary>\r
+            Private constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Private constructor for singleton pattern.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.NullSecurityContext.Impersonate(System.Object)">\r
+            <summary>\r
+            Impersonate this SecurityContext\r
+            </summary>\r
+            <param name="state">State supplied by the caller</param>\r
+            <returns><c>null</c></returns>\r
+            <remarks>\r
+            <para>\r
+            No impersonation is done and <c>null</c> is always returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.OnlyOnceErrorHandler">\r
+            <summary>\r
+            Implements log4net's default error handling policy which consists \r
+            of emitting a message for the first error in an appender and \r
+            ignoring all subsequent errors.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The error message is processed using the LogLog sub-system by default.\r
+            </para>\r
+            <para>\r
+            This policy aims at protecting an otherwise working application\r
+            from being flooded with error messages when logging fails.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Ron Grabowski</author>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor">\r
+            <summary>\r
+            Default Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.#ctor(System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="prefix">The prefix to use for each message.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/> class\r
+            with the specified prefix.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Reset">\r
+            <summary>\r
+            Reset the error handler back to its initial disabled state.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception,log4net.Core.ErrorCode)">\r
+            <summary>\r
+            Log an Error\r
+            </summary>\r
+            <param name="message">The error message.</param>\r
+            <param name="e">The exception.</param>\r
+            <param name="errorCode">The internal error code.</param>\r
+            <remarks>\r
+            <para>\r
+            Invokes <see cref="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)"/> if and only if this is the first error or the first error after <see cref="M:log4net.Util.OnlyOnceErrorHandler.Reset"/> has been called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)">\r
+            <summary>\r
+            Log the very first error\r
+            </summary>\r
+            <param name="message">The error message.</param>\r
+            <param name="e">The exception.</param>\r
+            <param name="errorCode">The internal error code.</param>\r
+            <remarks>\r
+            <para>\r
+            Sends the error information to <see cref="T:log4net.Util.LogLog"/>'s Error method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String,System.Exception)">\r
+            <summary>\r
+            Log an Error\r
+            </summary>\r
+            <param name="message">The error message.</param>\r
+            <param name="e">The exception.</param>\r
+            <remarks>\r
+            <para>\r
+            Invokes <see cref="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)"/> if and only if this is the first error or the first error after <see cref="M:log4net.Util.OnlyOnceErrorHandler.Reset"/> has been called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OnlyOnceErrorHandler.Error(System.String)">\r
+            <summary>\r
+            Log an error\r
+            </summary>\r
+            <param name="message">The error message.</param>\r
+            <remarks>\r
+            <para>\r
+            Invokes <see cref="M:log4net.Util.OnlyOnceErrorHandler.FirstError(System.String,System.Exception,log4net.Core.ErrorCode)"/> if and only if this is the first error or the first error after <see cref="M:log4net.Util.OnlyOnceErrorHandler.Reset"/> has been called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_enabledDate">\r
+            <summary>\r
+            The date the error was recorded.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_firstTime">\r
+            <summary>\r
+            Flag to indicate if it is the first error\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_message">\r
+            <summary>\r
+            The message recorded during the first error.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_exception">\r
+            <summary>\r
+            The exception recorded during the first error.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_errorCode">\r
+            <summary>\r
+            The error code recorded during the first error.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.m_prefix">\r
+            <summary>\r
+            String to prefix each message with\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.OnlyOnceErrorHandler.declaringType">\r
+            <summary>\r
+            The fully qualified type of the OnlyOnceErrorHandler class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.IsEnabled">\r
+            <summary>\r
+            Is error logging enabled\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Is error logging enabled. Logging is only enabled for the\r
+            first error delivered to the <see cref="T:log4net.Util.OnlyOnceErrorHandler"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.EnabledDate">\r
+            <summary>\r
+            The date the first error that trigged this error handler occured.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorMessage">\r
+            <summary>\r
+            The message from the first error that trigged this error handler.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.Exception">\r
+            <summary>\r
+            The exception from the first error that trigged this error handler.\r
+            </summary>\r
+            <remarks>\r
+            May be <see langword="null" />.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.OnlyOnceErrorHandler.ErrorCode">\r
+            <summary>\r
+            The error code from the first error that trigged this error handler.\r
+            </summary>\r
+            <remarks>\r
+            Defaults to <see cref="F:log4net.Core.ErrorCode.GenericFailure"/>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.OptionConverter">\r
+            <summary>\r
+            A convenience class to convert property values to specific types.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Utility functions for converting types and parsing values.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.OptionConverter"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.ToBoolean(System.String,System.Boolean)">\r
+            <summary>\r
+            Converts a string to a <see cref="T:System.Boolean"/> value.\r
+            </summary>\r
+            <param name="argValue">String to convert.</param>\r
+            <param name="defaultValue">The default value.</param>\r
+            <returns>The <see cref="T:System.Boolean"/> value of <paramref name="argValue"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            If <paramref name="argValue"/> is "true", then <c>true</c> is returned. \r
+            If <paramref name="argValue"/> is "false", then <c>false</c> is returned. \r
+            Otherwise, <paramref name="defaultValue"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.ToFileSize(System.String,System.Int64)">\r
+            <summary>\r
+            Parses a file size into a number.\r
+            </summary>\r
+            <param name="argValue">String to parse.</param>\r
+            <param name="defaultValue">The default value.</param>\r
+            <returns>The <see cref="T:System.Int64"/> value of <paramref name="argValue"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            Parses a file size of the form: number[KB|MB|GB] into a\r
+            long value. It is scaled with the appropriate multiplier.\r
+            </para>\r
+            <para>\r
+            <paramref name="defaultValue"/> is returned when <paramref name="argValue"/>\r
+            cannot be converted to a <see cref="T:System.Int64"/> value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.ConvertStringTo(System.Type,System.String)">\r
+            <summary>\r
+            Converts a string to an object.\r
+            </summary>\r
+            <param name="target">The target type to convert to.</param>\r
+            <param name="txt">The string to convert to an object.</param>\r
+            <returns>\r
+            The object converted from a string or <c>null</c> when the \r
+            conversion failed.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Converts a string to an object. Uses the converter registry to try\r
+            to convert the string value into the specified target type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.CanConvertTypeTo(System.Type,System.Type)">\r
+            <summary>\r
+            Checks if there is an appropriate type conversion from the source type to the target type.\r
+            </summary>\r
+            <param name="sourceType">The type to convert from.</param>\r
+            <param name="targetType">The type to convert to.</param>\r
+            <returns><c>true</c> if there is a conversion from the source type to the target type.</returns>\r
+            <remarks>\r
+            Checks if there is an appropriate type conversion from the source type to the target type.\r
+            <para>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.ConvertTypeTo(System.Object,System.Type)">\r
+            <summary>\r
+            Converts an object to the target type.\r
+            </summary>\r
+            <param name="sourceInstance">The object to convert to the target type.</param>\r
+            <param name="targetType">The type to convert to.</param>\r
+            <returns>The converted object.</returns>\r
+            <remarks>\r
+            <para>\r
+            Converts an object to the target type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.InstantiateByClassName(System.String,System.Type,System.Object)">\r
+            <summary>\r
+            Instantiates an object given a class name.\r
+            </summary>\r
+            <param name="className">The fully qualified class name of the object to instantiate.</param>\r
+            <param name="superClass">The class to which the new object should belong.</param>\r
+            <param name="defaultValue">The object to return in case of non-fulfillment.</param>\r
+            <returns>\r
+            An instance of the <paramref name="className"/> or <paramref name="defaultValue"/>\r
+            if the object could not be instantiated.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Checks that the <paramref name="className"/> is a subclass of\r
+            <paramref name="superClass"/>. If that test fails or the object could\r
+            not be instantiated, then <paramref name="defaultValue"/> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.SubstituteVariables(System.String,System.Collections.IDictionary)">\r
+            <summary>\r
+            Performs variable substitution in string <paramref name="value"/> from the \r
+            values of keys found in <paramref name="props"/>.\r
+            </summary>\r
+            <param name="value">The string on which variable substitution is performed.</param>\r
+            <param name="props">The dictionary to use to lookup variables.</param>\r
+            <returns>The result of the substitutions.</returns>\r
+            <remarks>\r
+            <para>\r
+            The variable substitution delimiters are <b>${</b> and <b>}</b>.\r
+            </para>\r
+            <para>\r
+            For example, if props contains <c>key=value</c>, then the call\r
+            </para>\r
+            <para>\r
+            <code lang="C#">\r
+            string s = OptionConverter.SubstituteVariables("Value of key is ${key}.");\r
+            </code>\r
+            </para>\r
+            <para>\r
+            will set the variable <c>s</c> to "Value of key is value.".\r
+            </para>\r
+            <para>\r
+            If no value could be found for the specified key, then substitution \r
+            defaults to an empty string.\r
+            </para>\r
+            <para>\r
+            For example, if system properties contains no value for the key\r
+            "nonExistentKey", then the call\r
+            </para>\r
+            <para>\r
+            <code lang="C#">\r
+            string s = OptionConverter.SubstituteVariables("Value of nonExistentKey is [${nonExistentKey}]");\r
+            </code>\r
+            </para>\r
+            <para>\r
+            will set <s>s</s> to "Value of nonExistentKey is []".       \r
+            </para>\r
+            <para>\r
+            An Exception is thrown if <paramref name="value"/> contains a start \r
+            delimiter "${" which is not balanced by a stop delimiter "}". \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.OptionConverter.ParseEnum(System.Type,System.String,System.Boolean)">\r
+            <summary>\r
+            Converts the string representation of the name or numeric value of one or \r
+            more enumerated constants to an equivalent enumerated object.\r
+            </summary>\r
+            <param name="enumType">The type to convert to.</param>\r
+            <param name="value">The enum string value.</param>\r
+            <param name="ignoreCase">If <c>true</c>, ignore case; otherwise, regard case.</param>\r
+            <returns>An object of type <paramref name="enumType" /> whose value is represented by <paramref name="value" />.</returns>\r
+        </member>\r
+        <member name="F:log4net.Util.OptionConverter.declaringType">\r
+            <summary>\r
+            The fully qualified type of the OptionConverter class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternParser">\r
+            <summary>\r
+            Most of the work of the <see cref="T:log4net.Layout.PatternLayout"/> class\r
+            is delegated to the PatternParser class.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>PatternParser</c> processes a pattern string and\r
+            returns a chain of <see cref="T:log4net.Util.PatternConverter"/> objects.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.#ctor(System.String)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="pattern">The pattern to parse.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.PatternParser"/> class \r
+            with the specified pattern string.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.Parse">\r
+            <summary>\r
+            Parses the pattern into a chain of pattern converters.\r
+            </summary>\r
+            <returns>The head of a chain of pattern converters.</returns>\r
+            <remarks>\r
+            <para>\r
+            Parses the pattern into a chain of pattern converters.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.BuildCache">\r
+            <summary>\r
+            Build the unified cache of converters from the static and instance maps\r
+            </summary>\r
+            <returns>the list of all the converter names</returns>\r
+            <remarks>\r
+            <para>\r
+            Build the unified cache of converters from the static and instance maps\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.ParseInternal(System.String,System.String[])">\r
+            <summary>\r
+            Internal method to parse the specified pattern to find specified matches\r
+            </summary>\r
+            <param name="pattern">the pattern to parse</param>\r
+            <param name="matches">the converter names to match in the pattern</param>\r
+            <remarks>\r
+            <para>\r
+            The matches param must be sorted such that longer strings come before shorter ones.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.ProcessLiteral(System.String)">\r
+            <summary>\r
+            Process a parsed literal\r
+            </summary>\r
+            <param name="text">the literal text</param>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.ProcessConverter(System.String,System.String,log4net.Util.FormattingInfo)">\r
+            <summary>\r
+            Process a parsed converter pattern\r
+            </summary>\r
+            <param name="converterName">the name of the converter</param>\r
+            <param name="option">the optional option for the converter</param>\r
+            <param name="formattingInfo">the formatting info for the converter</param>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternParser.AddConverter(log4net.Util.PatternConverter)">\r
+            <summary>\r
+            Resets the internal state of the parser and adds the specified pattern converter \r
+            to the chain.\r
+            </summary>\r
+            <param name="pc">The pattern converter to add.</param>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternParser.m_head">\r
+            <summary>\r
+            The first pattern converter in the chain\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternParser.m_tail">\r
+            <summary>\r
+             the last pattern converter in the chain\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternParser.m_pattern">\r
+            <summary>\r
+            The pattern\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternParser.m_patternConverters">\r
+            <summary>\r
+            Internal map of converter identifiers to converter types\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This map overrides the static s_globalRulesRegistry map.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternParser.declaringType">\r
+            <summary>\r
+            The fully qualified type of the PatternParser class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PatternParser.PatternConverters">\r
+            <summary>\r
+            Get the converter registry used by this parser\r
+            </summary>\r
+            <value>\r
+            The converter registry used by this parser\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Get the converter registry used by this parser\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternParser.StringLengthComparer">\r
+            <summary>\r
+            Sort strings by length\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <see cref="T:System.Collections.IComparer"/> that orders strings by string length.\r
+            The longest strings are placed first\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PatternString">\r
+            <summary>\r
+            This class implements a patterned string.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This string has embedded patterns that are resolved and expanded\r
+            when the string is formatted.\r
+            </para>\r
+            <para>\r
+            This class functions similarly to the <see cref="T:log4net.Layout.PatternLayout"/>\r
+            in that it accepts a pattern and renders it to a string. Unlike the \r
+            <see cref="T:log4net.Layout.PatternLayout"/> however the <c>PatternString</c>\r
+            does not render the properties of a specific <see cref="T:log4net.Core.LoggingEvent"/> but\r
+            of the process in general.\r
+            </para>\r
+            <para>\r
+            The recognized conversion pattern names are:\r
+            </para>\r
+            <list type="table">\r
+                <listheader>\r
+                    <term>Conversion Pattern Name</term>\r
+                    <description>Effect</description>\r
+                </listheader>\r
+                <item>\r
+                    <term>appdomain</term>\r
+                    <description>\r
+                        <para>\r
+                        Used to output the friendly name of the current AppDomain.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>date</term>\r
+                    <description>\r
+                               <para>\r
+                               Used to output the current date and time in the local time zone. \r
+                               To output the date in universal time use the <c>%utcdate</c> pattern.\r
+                               The date conversion \r
+                               specifier may be followed by a <i>date format specifier</i> enclosed \r
+                               between braces. For example, <b>%date{HH:mm:ss,fff}</b> or\r
+                               <b>%date{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is \r
+                               given then ISO8601 format is\r
+                               assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).\r
+                               </para>\r
+                               <para>\r
+                               The date format specifier admits the same syntax as the\r
+                               time pattern string of the <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                               <para>\r
+                               For better results it is recommended to use the log4net date\r
+                               formatters. These can be specified using one of the strings\r
+                               "ABSOLUTE", "DATE" and "ISO8601" for specifying \r
+                               <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, \r
+                               <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively \r
+                               <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, \r
+                               <b>%date{ISO8601}</b> or <b>%date{ABSOLUTE}</b>.\r
+                               </para>\r
+                               <para>\r
+                               These dedicated date formatters perform significantly\r
+                               better than <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>env</term>\r
+                    <description>\r
+                        <para>\r
+                               Used to output the a specific environment variable. The key to \r
+                               lookup must be specified within braces and directly following the\r
+                               pattern specifier, e.g. <b>%env{COMPUTERNAME}</b> would include the value\r
+                               of the <c>COMPUTERNAME</c> environment variable.\r
+                        </para>\r
+                        <para>\r
+                        The <c>env</c> pattern is not supported on the .NET Compact Framework.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>identity</term>\r
+                    <description>\r
+                               <para>\r
+                               Used to output the user name for the currently active user\r
+                               (Principal.Identity.Name).\r
+                               </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>newline</term>\r
+                    <description>\r
+                               <para>\r
+                               Outputs the platform dependent line separator character or\r
+                               characters.\r
+                               </para>\r
+                               <para>\r
+                               This conversion pattern name offers the same performance as using \r
+                               non-portable line separator strings such as     "\n", or "\r\n". \r
+                               Thus, it is the preferred way of specifying a line separator.\r
+                               </para> \r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>processid</term>\r
+                    <description>\r
+                        <para>\r
+                               Used to output the system process ID for the current process.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>property</term>\r
+                    <description>\r
+                               <para>\r
+                               Used to output a specific context property. The key to \r
+                               lookup must be specified within braces and directly following the\r
+                               pattern specifier, e.g. <b>%property{user}</b> would include the value\r
+                               from the property that is keyed by the string 'user'. Each property value\r
+                               that is to be included in the log must be specified separately.\r
+                               Properties are stored in logging contexts. By default \r
+                               the <c>log4net:HostName</c> property is set to the name of machine on \r
+                               which the event was originally logged.\r
+                               </para>\r
+                               <para>\r
+                               If no key is specified, e.g. <b>%property</b> then all the keys and their\r
+                               values are printed in a comma separated list.\r
+                               </para>\r
+                               <para>\r
+                               The properties of an event are combined from a number of different\r
+                               contexts. These are listed below in the order in which they are searched.\r
+                               </para>\r
+                               <list type="definition">\r
+                                       <item>\r
+                                               <term>the thread properties</term>\r
+                                               <description>\r
+                                               The <see cref="P:log4net.ThreadContext.Properties"/> that are set on the current\r
+                                               thread. These properties are shared by all events logged on this thread.\r
+                                               </description>\r
+                                       </item>\r
+                                       <item>\r
+                                               <term>the global properties</term>\r
+                                               <description>\r
+                                               The <see cref="P:log4net.GlobalContext.Properties"/> that are set globally. These \r
+                                               properties are shared by all the threads in the AppDomain.\r
+                                               </description>\r
+                                       </item>\r
+                               </list>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>random</term>\r
+                    <description>\r
+                        <para>\r
+                        Used to output a random string of characters. The string is made up of\r
+                        uppercase letters and numbers. By default the string is 4 characters long.\r
+                        The length of the string can be specified within braces directly following the\r
+                               pattern specifier, e.g. <b>%random{8}</b> would output an 8 character string.\r
+                        </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>username</term>\r
+                    <description>\r
+                               <para>\r
+                               Used to output the WindowsIdentity for the currently\r
+                               active user.\r
+                               </para>\r
+                    </description>\r
+                </item>\r
+                <item>\r
+                    <term>utcdate</term>\r
+                    <description>\r
+                               <para>\r
+                               Used to output the date of the logging event in universal time. \r
+                               The date conversion \r
+                               specifier may be followed by a <i>date format specifier</i> enclosed \r
+                               between braces. For example, <b>%utcdate{HH:mm:ss,fff}</b> or\r
+                               <b>%utcdate{dd MMM yyyy HH:mm:ss,fff}</b>.  If no date format specifier is \r
+                               given then ISO8601 format is\r
+                               assumed (<see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>).\r
+                               </para>\r
+                               <para>\r
+                               The date format specifier admits the same syntax as the\r
+                               time pattern string of the <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                               <para>\r
+                               For better results it is recommended to use the log4net date\r
+                               formatters. These can be specified using one of the strings\r
+                               "ABSOLUTE", "DATE" and "ISO8601" for specifying \r
+                               <see cref="T:log4net.DateFormatter.AbsoluteTimeDateFormatter"/>, \r
+                               <see cref="T:log4net.DateFormatter.DateTimeDateFormatter"/> and respectively \r
+                               <see cref="T:log4net.DateFormatter.Iso8601DateFormatter"/>. For example, \r
+                               <b>%utcdate{ISO8601}</b> or <b>%utcdate{ABSOLUTE}</b>.\r
+                               </para>\r
+                               <para>\r
+                               These dedicated date formatters perform significantly\r
+                               better than <see cref="M:DateTime.ToString(string)"/>.\r
+                               </para>\r
+                    </description>\r
+                </item>\r
+               <item>\r
+                       <term>%</term>\r
+                       <description>\r
+                               <para>\r
+                               The sequence %% outputs a single percent sign.\r
+                               </para>\r
+                       </description>\r
+               </item>\r
+            </list>\r
+            <para>\r
+            Additional pattern converters may be registered with a specific <see cref="T:log4net.Util.PatternString"/>\r
+            instance using <see cref="M:AddConverter(ConverterInfo)"/> or\r
+            <see cref="M:AddConverter(string, Type)"/>.\r
+            </para>\r
+            <para>\r
+            See the <see cref="T:log4net.Layout.PatternLayout"/> for details on the \r
+            <i>format modifiers</i> supported by the patterns.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternString.s_globalRulesRegistry">\r
+            <summary>\r
+            Internal map of converter identifiers to converter types.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternString.m_pattern">\r
+            <summary>\r
+            the pattern\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternString.m_head">\r
+            <summary>\r
+            the head of the pattern converter chain\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.PatternString.m_instanceRulesRegistry">\r
+            <summary>\r
+            patterns defined on this PatternString only\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.#cctor">\r
+            <summary>\r
+            Initialize the global registry\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.#ctor(System.String)">\r
+            <summary>\r
+            Constructs a PatternString\r
+            </summary>\r
+            <param name="pattern">The pattern to use with this PatternString</param>\r
+            <remarks>\r
+            <para>\r
+            Initialize a new instance of <see cref="T:log4net.Util.PatternString"/> with the pattern specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.ActivateOptions">\r
+            <summary>\r
+            Initialize object options\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Util.PatternString.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Util.PatternString.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Util.PatternString.ActivateOptions"/> must be called again.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.CreatePatternParser(System.String)">\r
+            <summary>\r
+            Create the <see cref="T:log4net.Util.PatternParser"/> used to parse the pattern\r
+            </summary>\r
+            <param name="pattern">the pattern to parse</param>\r
+            <returns>The <see cref="T:log4net.Util.PatternParser"/></returns>\r
+            <remarks>\r
+            <para>\r
+            Returns PatternParser used to parse the conversion string. Subclasses\r
+            may override this to return a subclass of PatternParser which recognize\r
+            custom conversion pattern name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.Format(System.IO.TextWriter)">\r
+            <summary>\r
+            Produces a formatted string as specified by the conversion pattern.\r
+            </summary>\r
+            <param name="writer">The TextWriter to write the formatted event to</param>\r
+            <remarks>\r
+            <para>\r
+            Format the pattern to the <paramref name="writer"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.Format">\r
+            <summary>\r
+            Format the pattern as a string\r
+            </summary>\r
+            <returns>the pattern formatted as a string</returns>\r
+            <remarks>\r
+            <para>\r
+            Format the pattern to a string.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.AddConverter(log4net.Util.ConverterInfo)">\r
+            <summary>\r
+            Add a converter to this PatternString\r
+            </summary>\r
+            <param name="converterInfo">the converter info</param>\r
+            <remarks>\r
+            <para>\r
+            This version of the method is used by the configurator.\r
+            Programmatic users should use the alternative <see cref="M:AddConverter(string,Type)"/> method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PatternString.AddConverter(System.String,System.Type)">\r
+            <summary>\r
+            Add a converter to this PatternString\r
+            </summary>\r
+            <param name="name">the name of the conversion pattern for this converter</param>\r
+            <param name="type">the type of the converter</param>\r
+            <remarks>\r
+            <para>\r
+            Add a converter to this PatternString\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PatternString.ConversionPattern">\r
+            <summary>\r
+            Gets or sets the pattern formatting string\r
+            </summary>\r
+            <value>\r
+            The pattern formatting string\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <b>ConversionPattern</b> option. This is the string which\r
+            controls formatting and consists of a mix of literal content and\r
+            conversion specifiers.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.PropertiesDictionary">\r
+            <summary>\r
+            String keyed object map.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            While this collection is serializable only member \r
+            objects that are serializable will\r
+            be serialized along with this collection.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="T:log4net.Util.ReadOnlyPropertiesDictionary">\r
+            <summary>\r
+            String keyed object map that is read only.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This collection is readonly and cannot be modified.\r
+            </para>\r
+            <para>\r
+            While this collection is serializable only member \r
+            objects that are serializable will\r
+            be serialized along with this collection.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="F:log4net.Util.ReadOnlyPropertiesDictionary.m_hashtable">\r
+            <summary>\r
+            The Hashtable used to store the properties data\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">\r
+            <summary>\r
+            Copy Constructor\r
+            </summary>\r
+            <param name="propertiesDictionary">properties to copy</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Deserialization constructor\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>\r
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ReadOnlyPropertiesDictionary"/> class \r
+            with serialized data.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetKeys">\r
+            <summary>\r
+            Gets the key names.\r
+            </summary>\r
+            <returns>An array of all the keys.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the key names.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Contains(System.String)">\r
+            <summary>\r
+            Test if the dictionary contains a specified key\r
+            </summary>\r
+            <param name="key">the key to look for</param>\r
+            <returns>true if the dictionary contains the specified key</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if the dictionary contains a specified key\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data.</param>\r
+            <param name="context">The destination for this serialization.</param>\r
+            <remarks>\r
+            <para>\r
+            Serializes this object into the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> provided.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#GetEnumerator">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>\r
+            </summary>\r
+            <param name="key"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>\r
+            </summary>\r
+            <param name="key"></param>\r
+            <returns></returns>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.Clear">\r
+            <summary>\r
+            Remove all properties from the properties collection\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>\r
+            </summary>\r
+            <param name="key"></param>\r
+            <param name="value"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>\r
+            </summary>\r
+            <param name="array"></param>\r
+            <param name="index"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Item(System.String)">\r
+            <summary>\r
+            Gets or sets the value of the  property with the specified key.\r
+            </summary>\r
+            <value>\r
+            The value of the property with the specified key.\r
+            </value>\r
+            <param name="key">The key of the property to get or set.</param>\r
+            <remarks>\r
+            <para>\r
+            The property value will only be serialized if it is serializable.\r
+            If it cannot be serialized it will be silently ignored if\r
+            a serialization operation is performed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.InnerHashtable">\r
+            <summary>\r
+            The hashtable used to store the properties\r
+            </summary>\r
+            <value>\r
+            The internal collection used to store the properties\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The hashtable used to store the properties\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsReadOnly">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Values">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.Values"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#Keys">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.Keys"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#IDictionary#IsFixedSize">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#IsSynchronized">\r
+            <summary>\r
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.Count">\r
+            <summary>\r
+            The number of properties in this collection\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.ReadOnlyPropertiesDictionary.System#Collections#ICollection#SyncRoot">\r
+            <summary>\r
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(log4net.Util.ReadOnlyPropertiesDictionary)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="propertiesDictionary">properties to copy</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.PropertiesDictionary"/> class \r
+            with serialized data.\r
+            </summary>\r
+            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data.</param>\r
+            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>\r
+            <remarks>\r
+            <para>\r
+            Because this class is sealed the serialization constructor is private.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.Remove(System.String)">\r
+            <summary>\r
+            Remove the entry with the specified key from this dictionary\r
+            </summary>\r
+            <param name="key">the key for the entry to remove</param>\r
+            <remarks>\r
+            <para>\r
+            Remove the entry with the specified key from this dictionary\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#GetEnumerator">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.GetEnumerator"/>\r
+            </summary>\r
+            <returns>an enumerator</returns>\r
+            <remarks>\r
+            <para>\r
+            Returns a <see cref="T:System.Collections.IDictionaryEnumerator"/> over the contest of this collection.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Remove(System.Object)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.Remove(System.Object)"/>\r
+            </summary>\r
+            <param name="key">the key to remove</param>\r
+            <remarks>\r
+            <para>\r
+            Remove the entry with the specified key from this dictionary\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Contains(System.Object)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.Contains(System.Object)"/>\r
+            </summary>\r
+            <param name="key">the key to lookup in the collection</param>\r
+            <returns><c>true</c> if the collection contains the specified key</returns>\r
+            <remarks>\r
+            <para>\r
+            Test if this collection contains a specified key.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.Clear">\r
+            <summary>\r
+            Remove all properties from the properties collection\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Remove all properties from the properties collection\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Add(System.Object,System.Object)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IDictionary.Add(System.Object,System.Object)"/>\r
+            </summary>\r
+            <param name="key">the key</param>\r
+            <param name="value">the value to store for the key</param>\r
+            <remarks>\r
+            <para>\r
+            Store a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#ICollection#CopyTo(System.Array,System.Int32)">\r
+            <summary>\r
+            See <see cref="M:System.Collections.ICollection.CopyTo(System.Array,System.Int32)"/>\r
+            </summary>\r
+            <param name="array"></param>\r
+            <param name="index"></param>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">\r
+            <summary>\r
+            See <see cref="M:System.Collections.IEnumerable.GetEnumerator"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.Item(System.String)">\r
+            <summary>\r
+            Gets or sets the value of the  property with the specified key.\r
+            </summary>\r
+            <value>\r
+            The value of the property with the specified key.\r
+            </value>\r
+            <param name="key">The key of the property to get or set.</param>\r
+            <remarks>\r
+            <para>\r
+            The property value will only be serialized if it is serializable.\r
+            If it cannot be serialized it will be silently ignored if\r
+            a serialization operation is performed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsReadOnly">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.IsReadOnly"/>\r
+            </summary>\r
+            <value>\r
+            <c>false</c>\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This collection is modifiable. This property always\r
+            returns <c>false</c>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Item(System.Object)">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.Item(System.Object)"/>\r
+            </summary>\r
+            <value>\r
+            The value for the key specified.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Get or set a value for the specified <see cref="T:System.String"/> <paramref name="key"/>.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentException">Thrown if the <paramref name="key"/> is not a string</exception>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Values">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.Values"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#Keys">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.Keys"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#IDictionary#IsFixedSize">\r
+            <summary>\r
+            See <see cref="P:System.Collections.IDictionary.IsFixedSize"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#IsSynchronized">\r
+            <summary>\r
+            See <see cref="P:System.Collections.ICollection.IsSynchronized"/>\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertiesDictionary.System#Collections#ICollection#SyncRoot">\r
+            <summary>\r
+            See <see cref="P:System.Collections.ICollection.SyncRoot"/>\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.PropertyEntry">\r
+            <summary>\r
+            A class to hold the key and data for a property set in the config file\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A class to hold the key and data for a property set in the config file\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.PropertyEntry.ToString">\r
+            <summary>\r
+            Override <c>Object.ToString</c> to return sensible debug info\r
+            </summary>\r
+            <returns>string info about this object</returns>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertyEntry.Key">\r
+            <summary>\r
+            Property Key\r
+            </summary>\r
+            <value>\r
+            Property Key\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Property Key.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.PropertyEntry.Value">\r
+            <summary>\r
+            Property Value\r
+            </summary>\r
+            <value>\r
+            Property Value\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Property Value.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ProtectCloseTextWriter">\r
+            <summary>\r
+            A <see cref="T:System.IO.TextWriter"/> that ignores the <see cref="M:log4net.Util.ProtectCloseTextWriter.Close"/> message\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This writer is used in special cases where it is necessary \r
+            to protect a writer from being closed by a client.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.ProtectCloseTextWriter.#ctor(System.IO.TextWriter)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="writer">the writer to actually write to</param>\r
+            <remarks>\r
+            <para>\r
+            Create a new ProtectCloseTextWriter using a writer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Attach(System.IO.TextWriter)">\r
+            <summary>\r
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>\r
+            </summary>\r
+            <param name="writer">the writer to attach to</param>\r
+            <remarks>\r
+            <para>\r
+            Attach this instance to a different underlying <see cref="T:System.IO.TextWriter"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ProtectCloseTextWriter.Close">\r
+            <summary>\r
+            Does not close the underlying output writer.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Does not close the underlying output writer.\r
+            This method does nothing.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ReaderWriterLock">\r
+            <summary>\r
+            Defines a lock that supports single writers and multiple readers\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <c>ReaderWriterLock</c> is used to synchronize access to a resource. \r
+            At any given time, it allows either concurrent read access for \r
+            multiple threads, or write access for a single thread. In a \r
+            situation where a resource is changed infrequently, a \r
+            <c>ReaderWriterLock</c> provides better throughput than a simple \r
+            one-at-a-time lock, such as <see cref="T:System.Threading.Monitor"/>.\r
+            </para>\r
+            <para>\r
+            If a platform does not support a <c>System.Threading.ReaderWriterLock</c> \r
+            implementation then all readers and writers are serialized. Therefore \r
+            the caller must not rely on multiple simultaneous readers.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.ReaderWriterLock.#ctor">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ReaderWriterLock"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireReaderLock">\r
+            <summary>\r
+            Acquires a reader lock\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <see cref="M:log4net.Util.ReaderWriterLock.AcquireReaderLock"/> blocks if a different thread has the writer \r
+            lock, or if at least one thread is waiting for the writer lock.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock">\r
+            <summary>\r
+            Decrements the lock count\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <see cref="M:log4net.Util.ReaderWriterLock.ReleaseReaderLock"/> decrements the lock count. When the count \r
+            reaches zero, the lock is released.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReaderWriterLock.AcquireWriterLock">\r
+            <summary>\r
+            Acquires the writer lock\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This method blocks if another thread has a reader lock or writer lock.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReaderWriterLock.ReleaseWriterLock">\r
+            <summary>\r
+            Decrements the lock count on the writer lock\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            ReleaseWriterLock decrements the writer lock count. \r
+            When the count reaches zero, the writer lock is released.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ReusableStringWriter">\r
+            <summary>\r
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            A <see cref="T:System.IO.StringWriter"/> that can be <see cref="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)"/> and reused.\r
+            This uses a single buffer for string operations.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.ReusableStringWriter.#ctor(System.IFormatProvider)">\r
+            <summary>\r
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>\r
+            </summary>\r
+            <param name="formatProvider">the format provider to use</param>\r
+            <remarks>\r
+            <para>\r
+            Create an instance of <see cref="T:log4net.Util.ReusableStringWriter"/>\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReusableStringWriter.Dispose(System.Boolean)">\r
+            <summary>\r
+            Override Dispose to prevent closing of writer\r
+            </summary>\r
+            <param name="disposing">flag</param>\r
+            <remarks>\r
+            <para>\r
+            Override Dispose to prevent closing of writer\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ReusableStringWriter.Reset(System.Int32,System.Int32)">\r
+            <summary>\r
+            Reset this string writer so that it can be reused.\r
+            </summary>\r
+            <param name="maxCapacity">the maximum buffer capacity before it is trimmed</param>\r
+            <param name="defaultSize">the default size to make the buffer</param>\r
+            <remarks>\r
+            <para>\r
+            Reset this string writer so that it can be reused.\r
+            The internal buffers are cleared and reset.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.SystemInfo">\r
+            <summary>\r
+            Utility class for system specific information.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Utility class of static methods for system specific information.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+            <author>Alexey Solofnenko</author>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.#ctor">\r
+            <summary>\r
+            Private constructor to prevent instances.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Only static methods are exposed from this type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.#cctor">\r
+            <summary>\r
+            Initialize default values for private static fields.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Only static methods are exposed from this type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.AssemblyLocationInfo(System.Reflection.Assembly)">\r
+            <summary>\r
+            Gets the assembly location path for the specified assembly.\r
+            </summary>\r
+            <param name="myAssembly">The assembly to get the location for.</param>\r
+            <returns>The location of the assembly.</returns>\r
+            <remarks>\r
+            <para>\r
+            This method does not guarantee to return the correct path\r
+            to the assembly. If only tries to give an indication as to\r
+            where the assembly was loaded from.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.AssemblyQualifiedName(System.Type)">\r
+            <summary>\r
+            Gets the fully qualified name of the <see cref="T:System.Type"/>, including \r
+            the name of the assembly from which the <see cref="T:System.Type"/> was \r
+            loaded.\r
+            </summary>\r
+            <param name="type">The <see cref="T:System.Type"/> to get the fully qualified name for.</param>\r
+            <returns>The fully qualified name for the <see cref="T:System.Type"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            This is equivalent to the <c>Type.AssemblyQualifiedName</c> property,\r
+            but this method works on the .NET Compact Framework 1.0 as well as\r
+            the full .NET runtime.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.AssemblyShortName(System.Reflection.Assembly)">\r
+            <summary>\r
+            Gets the short name of the <see cref="T:System.Reflection.Assembly"/>.\r
+            </summary>\r
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the name for.</param>\r
+            <returns>The short name of the <see cref="T:System.Reflection.Assembly"/>.</returns>\r
+            <remarks>\r
+            <para>\r
+            The short name of the assembly is the <see cref="P:System.Reflection.Assembly.FullName"/> \r
+            without the version, culture, or public key. i.e. it is just the \r
+            assembly's file name without the extension.\r
+            </para>\r
+            <para>\r
+            Use this rather than <c>Assembly.GetName().Name</c> because that\r
+            is not available on the Compact Framework.\r
+            </para>\r
+            <para>\r
+            Because of a FileIOPermission security demand we cannot do\r
+            the obvious Assembly.GetName().Name. We are allowed to get\r
+            the <see cref="P:System.Reflection.Assembly.FullName"/> of the assembly so we \r
+            start from there and strip out just the assembly name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.AssemblyFileName(System.Reflection.Assembly)">\r
+            <summary>\r
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.\r
+            </summary>\r
+            <param name="myAssembly">The <see cref="T:System.Reflection.Assembly"/> to get the file name for.</param>\r
+            <returns>The file name of the assembly.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the file name portion of the <see cref="T:System.Reflection.Assembly"/>, including the extension.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Type,System.String,System.Boolean,System.Boolean)">\r
+            <summary>\r
+            Loads the type specified in the type string.\r
+            </summary>\r
+            <param name="relativeType">A sibling type to use to load the type.</param>\r
+            <param name="typeName">The name of the type to load.</param>\r
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>\r
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>\r
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>\r
+            <remarks>\r
+            <para>\r
+            If the type name is fully qualified, i.e. if contains an assembly name in \r
+            the type name, the type will be loaded from the system using \r
+            <see cref="M:Type.GetType(string,bool)"/>.\r
+            </para>\r
+            <para>\r
+            If the type name is not fully qualified, it will be loaded from the assembly\r
+            containing the specified relative type. If the type is not found in the assembly \r
+            then all the loaded assemblies will be searched for the type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.String,System.Boolean,System.Boolean)">\r
+            <summary>\r
+            Loads the type specified in the type string.\r
+            </summary>\r
+            <param name="typeName">The name of the type to load.</param>\r
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>\r
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>\r
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>               \r
+            <remarks>\r
+            <para>\r
+            If the type name is fully qualified, i.e. if contains an assembly name in \r
+            the type name, the type will be loaded from the system using \r
+            <see cref="M:Type.GetType(string,bool)"/>.\r
+            </para>\r
+            <para>\r
+            If the type name is not fully qualified it will be loaded from the\r
+            assembly that is directly calling this method. If the type is not found \r
+            in the assembly then all the loaded assemblies will be searched for the type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.GetTypeFromString(System.Reflection.Assembly,System.String,System.Boolean,System.Boolean)">\r
+            <summary>\r
+            Loads the type specified in the type string.\r
+            </summary>\r
+            <param name="relativeAssembly">An assembly to load the type from.</param>\r
+            <param name="typeName">The name of the type to load.</param>\r
+            <param name="throwOnError">Flag set to <c>true</c> to throw an exception if the type cannot be loaded.</param>\r
+            <param name="ignoreCase"><c>true</c> to ignore the case of the type name; otherwise, <c>false</c></param>\r
+            <returns>The type loaded or <c>null</c> if it could not be loaded.</returns>\r
+            <remarks>\r
+            <para>\r
+            If the type name is fully qualified, i.e. if contains an assembly name in \r
+            the type name, the type will be loaded from the system using \r
+            <see cref="M:Type.GetType(string,bool)"/>.\r
+            </para>\r
+            <para>\r
+            If the type name is not fully qualified it will be loaded from the specified\r
+            assembly. If the type is not found in the assembly then all the loaded assemblies \r
+            will be searched for the type.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.NewGuid">\r
+            <summary>\r
+            Generate a new guid\r
+            </summary>\r
+            <returns>A new Guid</returns>\r
+            <remarks>\r
+            <para>\r
+            Generate a new guid\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.CreateArgumentOutOfRangeException(System.String,System.Object,System.String)">\r
+            <summary>\r
+            Create an <see cref="T:System.ArgumentOutOfRangeException"/>\r
+            </summary>\r
+            <param name="parameterName">The name of the parameter that caused the exception</param>\r
+            <param name="actualValue">The value of the argument that causes this exception</param>\r
+            <param name="message">The message that describes the error</param>\r
+            <returns>the ArgumentOutOfRangeException object</returns>\r
+            <remarks>\r
+            <para>\r
+            Create a new instance of the <see cref="T:System.ArgumentOutOfRangeException"/> class \r
+            with a specified error message, the parameter name, and the value \r
+            of the argument.\r
+            </para>\r
+            <para>\r
+            The Compact Framework does not support the 3 parameter constructor for the\r
+            <see cref="T:System.ArgumentOutOfRangeException"/> type. This method provides an\r
+            implementation that works for all platforms.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int32@)">\r
+            <summary>\r
+            Parse a string into an <see cref="T:System.Int32"/> value\r
+            </summary>\r
+            <param name="s">the string to parse</param>\r
+            <param name="val">out param where the parsed value is placed</param>\r
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>\r
+            <remarks>\r
+            <para>\r
+            Attempts to parse the string into an integer. If the string cannot\r
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int64@)">\r
+            <summary>\r
+            Parse a string into an <see cref="T:System.Int64"/> value\r
+            </summary>\r
+            <param name="s">the string to parse</param>\r
+            <param name="val">out param where the parsed value is placed</param>\r
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>\r
+            <remarks>\r
+            <para>\r
+            Attempts to parse the string into an integer. If the string cannot\r
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.TryParse(System.String,System.Int16@)">\r
+            <summary>\r
+            Parse a string into an <see cref="T:System.Int16"/> value\r
+            </summary>\r
+            <param name="s">the string to parse</param>\r
+            <param name="val">out param where the parsed value is placed</param>\r
+            <returns><c>true</c> if the string was able to be parsed into an integer</returns>\r
+            <remarks>\r
+            <para>\r
+            Attempts to parse the string into an integer. If the string cannot\r
+            be parsed then this method returns <c>false</c>. The method does not throw an exception.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.GetAppSetting(System.String)">\r
+            <summary>\r
+            Lookup an application setting\r
+            </summary>\r
+            <param name="key">the application settings key to lookup</param>\r
+            <returns>the value for the key, or <c>null</c></returns>\r
+            <remarks>\r
+            <para>\r
+            Configuration APIs are not supported under the Compact Framework\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.ConvertToFullPath(System.String)">\r
+            <summary>\r
+            Convert a path into a fully qualified local file path.\r
+            </summary>\r
+            <param name="path">The path to convert.</param>\r
+            <returns>The fully qualified path.</returns>\r
+            <remarks>\r
+            <para>\r
+            Converts the path specified to a fully\r
+            qualified path. If the path is relative it is\r
+            taken as relative from the application base \r
+            directory.\r
+            </para>\r
+            <para>\r
+            The path specified must be a local file path, a URI is not supported.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemInfo.CreateCaseInsensitiveHashtable">\r
+            <summary>\r
+            Creates a new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity. \r
+            </summary>\r
+            <returns>A new case-insensitive instance of the <see cref="T:System.Collections.Hashtable"/> class with the default initial capacity</returns>\r
+            <remarks>\r
+            <para>\r
+            The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.EmptyTypes">\r
+            <summary>\r
+            Gets an empty array of types.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>Type.EmptyTypes</c> field is not available on\r
+            the .NET Compact Framework 1.0.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.declaringType">\r
+            <summary>\r
+            The fully qualified type of the SystemInfo class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.s_hostName">\r
+            <summary>\r
+            Cache the host name for the current machine\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.s_appFriendlyName">\r
+            <summary>\r
+            Cache the application friendly name\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.s_nullText">\r
+            <summary>\r
+            Text to output when a <c>null</c> is encountered.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.s_notAvailableText">\r
+            <summary>\r
+            Text to output when an unsupported feature is requested.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemInfo.s_processStartTime">\r
+            <summary>\r
+            Start time for the current process.\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.NewLine">\r
+            <summary>\r
+            Gets the system dependent line terminator.\r
+            </summary>\r
+            <value>\r
+            The system dependent line terminator.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the system dependent line terminator.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.ApplicationBaseDirectory">\r
+            <summary>\r
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.\r
+            </summary>\r
+            <value>The base directory path for the current <see cref="T:System.AppDomain"/>.</value>\r
+            <remarks>\r
+            <para>\r
+            Gets the base directory for this <see cref="T:System.AppDomain"/>.\r
+            </para>\r
+            <para>\r
+            The value returned may be either a local file path or a URI.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.ConfigurationFileLocation">\r
+            <summary>\r
+            Gets the path to the configuration file for the current <see cref="T:System.AppDomain"/>.\r
+            </summary>\r
+            <value>The path to the configuration file for the current <see cref="T:System.AppDomain"/>.</value>\r
+            <remarks>\r
+            <para>\r
+            The .NET Compact Framework 1.0 does not have a concept of a configuration\r
+            file. For this runtime, we use the entry assembly location as the root for\r
+            the configuration file name.\r
+            </para>\r
+            <para>\r
+            The value returned may be either a local file path or a URI.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.EntryAssemblyLocation">\r
+            <summary>\r
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.\r
+            </summary>\r
+            <value>The path to the entry assembly.</value>\r
+            <remarks>\r
+            <para>\r
+            Gets the path to the file that first executed in the current <see cref="T:System.AppDomain"/>.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.CurrentThreadId">\r
+            <summary>\r
+            Gets the ID of the current thread.\r
+            </summary>\r
+            <value>The ID of the current thread.</value>\r
+            <remarks>\r
+            <para>\r
+            On the .NET framework, the <c>AppDomain.GetCurrentThreadId</c> method\r
+            is used to obtain the thread ID for the current thread. This is the \r
+            operating system ID for the thread.\r
+            </para>\r
+            <para>\r
+            On the .NET Compact Framework 1.0 it is not possible to get the \r
+            operating system thread ID for the current thread. The native method \r
+            <c>GetCurrentThreadId</c> is implemented inline in a header file\r
+            and cannot be called.\r
+            </para>\r
+            <para>\r
+            On the .NET Framework 2.0 the <c>Thread.ManagedThreadId</c> is used as this\r
+            gives a stable id unrelated to the operating system thread ID which may \r
+            change if the runtime is using fibers.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.HostName">\r
+            <summary>\r
+            Get the host name or machine name for the current machine\r
+            </summary>\r
+            <value>\r
+            The hostname or machine name\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Get the host name or machine name for the current machine\r
+            </para>\r
+            <para>\r
+            The host name (<see cref="M:System.Net.Dns.GetHostName"/>) or\r
+            the machine name (<c>Environment.MachineName</c>) for\r
+            the current machine, or if neither of these are available\r
+            then <c>NOT AVAILABLE</c> is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.ApplicationFriendlyName">\r
+            <summary>\r
+            Get this application's friendly name\r
+            </summary>\r
+            <value>\r
+            The friendly name of this application as a string\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            If available the name of the application is retrieved from\r
+            the <c>AppDomain</c> using <c>AppDomain.CurrentDomain.FriendlyName</c>.\r
+            </para>\r
+            <para>\r
+            Otherwise the file name of the entry assembly is used.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.ProcessStartTime">\r
+            <summary>\r
+            Get the start time for the current process.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is the time at which the log4net library was loaded into the\r
+            AppDomain. Due to reports of a hang in the call to <c>System.Diagnostics.Process.StartTime</c>\r
+            this is not the start time for the current process.\r
+            </para>\r
+            <para>\r
+            The log4net library should be loaded by an application early during its\r
+            startup, therefore this start time should be a good approximation for\r
+            the actual start time.\r
+            </para>\r
+            <para>\r
+            Note that AppDomains may be loaded and unloaded within the\r
+            same process without the process terminating, however this start time\r
+            will be set per AppDomain.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.NullText">\r
+            <summary>\r
+            Text to output when a <c>null</c> is encountered.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Use this value to indicate a <c>null</c> has been encountered while\r
+            outputting a string representation of an item.\r
+            </para>\r
+            <para>\r
+            The default value is <c>(null)</c>. This value can be overridden by specifying\r
+            a value for the <c>log4net.NullText</c> appSetting in the application's\r
+            .config file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.SystemInfo.NotAvailableText">\r
+            <summary>\r
+            Text to output when an unsupported feature is requested.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Use this value when an unsupported feature is requested.\r
+            </para>\r
+            <para>\r
+            The default value is <c>NOT AVAILABLE</c>. This value can be overridden by specifying\r
+            a value for the <c>log4net.NotAvailableText</c> appSetting in the application's\r
+            .config file.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.SystemStringFormat">\r
+            <summary>\r
+            Utility class that represents a format string.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Utility class that represents a format string.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemStringFormat.#ctor(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Initialise the <see cref="T:log4net.Util.SystemStringFormat"/>\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>\r
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>\r
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemStringFormat.ToString">\r
+            <summary>\r
+            Format the string and arguments\r
+            </summary>\r
+            <returns>the formatted string</returns>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemStringFormat.StringFormat(System.IFormatProvider,System.String,System.Object[])">\r
+            <summary>\r
+            Replaces the format item in a specified <see cref="T:System.String"/> with the text equivalent \r
+            of the value of a corresponding <see cref="T:System.Object"/> instance in a specified array.\r
+            A specified parameter supplies culture-specific formatting information.\r
+            </summary>\r
+            <param name="provider">An <see cref="T:System.IFormatProvider"/> that supplies culture-specific formatting information.</param>\r
+            <param name="format">A <see cref="T:System.String"/> containing zero or more format items.</param>\r
+            <param name="args">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>\r
+            <returns>\r
+            A copy of format in which the format items have been replaced by the <see cref="T:System.String"/> \r
+            equivalent of the corresponding instances of <see cref="T:System.Object"/> in args.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            This method does not throw exceptions. If an exception thrown while formatting the result the\r
+            exception and arguments are returned in the result string.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemStringFormat.StringFormatError(System.Exception,System.String,System.Object[])">\r
+            <summary>\r
+            Process an error during StringFormat\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemStringFormat.RenderArray(System.Array,System.Text.StringBuilder)">\r
+            <summary>\r
+            Dump the contents of an array into a string builder\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.SystemStringFormat.RenderObject(System.Object,System.Text.StringBuilder)">\r
+            <summary>\r
+            Dump an object to a string\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.SystemStringFormat.declaringType">\r
+            <summary>\r
+            The fully qualified type of the SystemStringFormat class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ThreadContextProperties">\r
+            <summary>\r
+            Implementation of Properties collection for the <see cref="T:log4net.ThreadContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Class implements a collection of properties that is specific to each thread.\r
+            The class is not synchronized as each thread has its own <see cref="T:log4net.Util.PropertiesDictionary"/>.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.ThreadContextProperties._dictionary">\r
+            <summary>\r
+            Each thread will automatically have its instance.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextProperties.#ctor">\r
+            <summary>\r
+            Internal constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextProperties"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextProperties.Remove(System.String)">\r
+            <summary>\r
+            Remove a property\r
+            </summary>\r
+            <param name="key">the key for the entry to remove</param>\r
+            <remarks>\r
+            <para>\r
+            Remove a property\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextProperties.GetKeys">\r
+            <summary>\r
+            Get the keys stored in the properties.\r
+            </summary>\r
+            <para>\r
+            Gets the keys stored in the properties.\r
+            </para>\r
+            <returns>a set of the defined keys</returns>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextProperties.Clear">\r
+            <summary>\r
+            Clear all properties\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clear all properties\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextProperties.GetProperties(System.Boolean)">\r
+            <summary>\r
+            Get the <c>PropertiesDictionary</c> for this thread.\r
+            </summary>\r
+            <param name="create">create the dictionary if it does not exist, otherwise return null if does not exist</param>\r
+            <returns>the properties for this thread</returns>\r
+            <remarks>\r
+            <para>\r
+            The collection returned is only to be used on the calling thread. If the\r
+            caller needs to share the collection between different threads then the \r
+            caller must clone the collection before doing so.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ThreadContextProperties.Item(System.String)">\r
+            <summary>\r
+            Gets or sets the value of a property\r
+            </summary>\r
+            <value>\r
+            The value for the property with the specified key\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets or sets the value of a property\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ThreadContextStack">\r
+            <summary>\r
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Implementation of Stack for the <see cref="T:log4net.ThreadContext"/>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="F:log4net.Util.ThreadContextStack.m_stack">\r
+            <summary>\r
+            The stack store.\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.#ctor">\r
+            <summary>\r
+            Internal constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack"/> class. \r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.Clear">\r
+            <summary>\r
+            Clears all the contextual information held in this stack.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Clears all the contextual information held in this stack.\r
+            Only call this if you think that this tread is being reused after\r
+            a previous call execution which may not have completed correctly.\r
+            You do not need to use this method if you always guarantee to call\r
+            the <see cref="M:System.IDisposable.Dispose"/> method of the <see cref="T:System.IDisposable"/>\r
+            returned from <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> even in exceptional circumstances,\r
+            for example by using the <c>using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))</c> \r
+            syntax.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.Pop">\r
+            <summary>\r
+            Removes the top context from this stack.\r
+            </summary>\r
+            <returns>The message in the context that was removed from the top of this stack.</returns>\r
+            <remarks>\r
+            <para>\r
+            Remove the top context from this stack, and return\r
+            it to the caller. If this stack is empty then an\r
+            empty string (not <see langword="null"/>) is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.Push(System.String)">\r
+            <summary>\r
+            Pushes a new context message into this stack.\r
+            </summary>\r
+            <param name="message">The new context message.</param>\r
+            <returns>\r
+            An <see cref="T:System.IDisposable"/> that can be used to clean up the context stack.\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Pushes a new context onto this stack. An <see cref="T:System.IDisposable"/>\r
+            is returned that can be used to clean up this stack. This\r
+            can be easily combined with the <c>using</c> keyword to scope the\r
+            context.\r
+            </para>\r
+            </remarks>\r
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.\r
+            <code lang="C#">\r
+            using(log4net.ThreadContext.Stacks["NDC"].Push("Stack_Message"))\r
+            {\r
+               log.Warn("This should have an ThreadContext Stack message");\r
+            }\r
+            </code>\r
+            </example>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.GetFullMessage">\r
+            <summary>\r
+            Gets the current context information for this stack.\r
+            </summary>\r
+            <returns>The current context information.</returns>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.ToString">\r
+            <summary>\r
+            Gets the current context information for this stack.\r
+            </summary>\r
+            <returns>Gets the current context information</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the current context information for this stack.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.log4net#Core#IFixingRequired#GetFixedObject">\r
+            <summary>\r
+            Get a portable version of this object\r
+            </summary>\r
+            <returns>the portable instance of this object</returns>\r
+            <remarks>\r
+            <para>\r
+            Get a cross thread portable version of this object\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ThreadContextStack.Count">\r
+            <summary>\r
+            The number of messages in the stack\r
+            </summary>\r
+            <value>\r
+            The current number of messages in the stack\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The current number of messages in the stack. That is\r
+            the number of times <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> has been called\r
+            minus the number of times <see cref="M:log4net.Util.ThreadContextStack.Pop"/> has been called.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ThreadContextStack.InternalStack">\r
+            <summary>\r
+            Gets and sets the internal stack used by this <see cref="T:log4net.Util.ThreadContextStack"/>\r
+            </summary>\r
+            <value>The internal storage stack</value>\r
+            <remarks>\r
+            <para>\r
+            This property is provided only to support backward compatability \r
+            of the <see cref="T:log4net.NDC"/>. Tytpically the internal stack should not\r
+            be modified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ThreadContextStack.StackFrame">\r
+            <summary>\r
+            Inner class used to represent a single context frame in the stack.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Inner class used to represent a single context frame in the stack.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.StackFrame.#ctor(System.String,log4net.Util.ThreadContextStack.StackFrame)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="message">The message for this context.</param>\r
+            <param name="parent">The parent context in the chain.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.StackFrame"/> class\r
+            with the specified message and parent context.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.Message">\r
+            <summary>\r
+            Get the message.\r
+            </summary>\r
+            <value>The message.</value>\r
+            <remarks>\r
+            <para>\r
+            Get the message.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ThreadContextStack.StackFrame.FullMessage">\r
+            <summary>\r
+            Gets the full text of the context down to the root level.\r
+            </summary>\r
+            <value>\r
+            The full text of the context down to the root level.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the full text of the context down to the root level.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ThreadContextStack.AutoPopStackFrame">\r
+            <summary>\r
+            Struct returned from the <see cref="M:log4net.Util.ThreadContextStack.Push(System.String)"/> method.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This struct implements the <see cref="T:System.IDisposable"/> and is designed to be used\r
+            with the <see langword="using"/> pattern to remove the stack frame at the end of the scope.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameStack">\r
+            <summary>\r
+            The ThreadContextStack internal stack\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.ThreadContextStack.AutoPopStackFrame.m_frameDepth">\r
+            <summary>\r
+            The depth to trim the stack to when this instance is disposed\r
+            </summary>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.#ctor(System.Collections.Stack,System.Int32)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="frameStack">The internal stack used by the ThreadContextStack.</param>\r
+            <param name="frameDepth">The depth to return the stack to when this object is disposed.</param>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStack.AutoPopStackFrame"/> class with\r
+            the specified stack and return depth.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStack.AutoPopStackFrame.Dispose">\r
+            <summary>\r
+            Returns the stack to the correct depth.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Returns the stack to the correct depth.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.ThreadContextStacks">\r
+            <summary>\r
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Implementation of Stacks collection for the <see cref="T:log4net.ThreadContext"/>\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.Util.ThreadContextStacks.#ctor(log4net.Util.ContextPropertiesBase)">\r
+            <summary>\r
+            Internal constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.ThreadContextStacks"/> class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.ThreadContextStacks.declaringType">\r
+            <summary>\r
+            The fully qualified type of the ThreadContextStacks class.\r
+            </summary>\r
+            <remarks>\r
+            Used by the internal logger to record the Type of the\r
+            log message.\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.ThreadContextStacks.Item(System.String)">\r
+            <summary>\r
+            Gets the named thread context stack\r
+            </summary>\r
+            <value>\r
+            The named stack\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Gets the named thread context stack\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.Transform">\r
+            <summary>\r
+            Utility class for transforming strings.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Utility class for transforming strings.\r
+            </para>\r
+            </remarks>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.Util.Transform.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.Util.Transform"/> class. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.Transform.WriteEscapedXmlString(System.Xml.XmlWriter,System.String,System.String)">\r
+            <summary>\r
+            Write a string to an <see cref="T:System.Xml.XmlWriter"/>\r
+            </summary>\r
+            <param name="writer">the writer to write to</param>\r
+            <param name="textData">the string to write</param>\r
+            <param name="invalidCharReplacement">The string to replace non XML compliant chars with</param>\r
+            <remarks>\r
+            <para>\r
+            The test is escaped either using XML escape entities\r
+            or using CDATA sections.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.Transform.MaskXmlInvalidCharacters(System.String,System.String)">\r
+            <summary>\r
+            Replace invalid XML characters in text string\r
+            </summary>\r
+            <param name="textData">the XML text input string</param>\r
+            <param name="mask">the string to use in place of invalid characters</param>\r
+            <returns>A string that does not contain invalid XML characters.</returns>\r
+            <remarks>\r
+            <para>\r
+            Certain Unicode code points are not allowed in the XML InfoSet, for\r
+            details see: <a href="http://www.w3.org/TR/REC-xml/#charsets">http://www.w3.org/TR/REC-xml/#charsets</a>.\r
+            </para>\r
+            <para>\r
+            This method replaces any illegal characters in the input string\r
+            with the mask string specified.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.Transform.CountSubstrings(System.String,System.String)">\r
+            <summary>\r
+            Count the number of times that the substring occurs in the text\r
+            </summary>\r
+            <param name="text">the text to search</param>\r
+            <param name="substring">the substring to find</param>\r
+            <returns>the number of times the substring occurs in the text</returns>\r
+            <remarks>\r
+            <para>\r
+            The substring is assumed to be non repeating within itself.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.Transform.INVALIDCHARS">\r
+            <summary>\r
+            Characters illegal in XML 1.0\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.WindowsSecurityContext">\r
+            <summary>\r
+            Impersonate a Windows Account\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This <see cref="T:log4net.Core.SecurityContext"/> impersonates a Windows account.\r
+            </para>\r
+            <para>\r
+            How the impersonation is done depends on the value of <see cref="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)"/>.\r
+            This allows the context to either impersonate a set of user credentials specified \r
+            using username, domain name and password or to revert to the process credentials.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.WindowsSecurityContext.#ctor">\r
+            <summary>\r
+            Default constructor\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Default constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.WindowsSecurityContext.ActivateOptions">\r
+            <summary>\r
+            Initialize the SecurityContext based on the options set.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object\r
+            activation scheme. The <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> method must \r
+            be called on this object after the configuration properties have\r
+            been set. Until <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> is called this\r
+            object is in an undefined state and must not be used. \r
+            </para>\r
+            <para>\r
+            If any of the configuration properties are modified then \r
+            <see cref="M:log4net.Util.WindowsSecurityContext.ActivateOptions"/> must be called again.\r
+            </para>\r
+            <para>\r
+            The security context will try to Logon the specified user account and\r
+            capture a primary token for impersonation.\r
+            </para>\r
+            </remarks>\r
+            <exception cref="T:System.ArgumentNullException">The required <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, \r
+            <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> or <see cref="P:log4net.Util.WindowsSecurityContext.Password"/> properties were not specified.</exception>\r
+        </member>\r
+        <member name="M:log4net.Util.WindowsSecurityContext.Impersonate(System.Object)">\r
+            <summary>\r
+            Impersonate the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.\r
+            </summary>\r
+            <param name="state">caller provided state</param>\r
+            <returns>\r
+            An <see cref="T:System.IDisposable"/> instance that will revoke the impersonation of this SecurityContext\r
+            </returns>\r
+            <remarks>\r
+            <para>\r
+            Depending on the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property either\r
+            impersonate a user using credentials supplied or revert \r
+            to the process credentials.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.WindowsSecurityContext.LogonUser(System.String,System.String,System.String)">\r
+            <summary>\r
+            Create a <see cref="T:System.Security.Principal.WindowsIdentity"/> given the userName, domainName and password.\r
+            </summary>\r
+            <param name="userName">the user name</param>\r
+            <param name="domainName">the domain name</param>\r
+            <param name="password">the password</param>\r
+            <returns>the <see cref="T:System.Security.Principal.WindowsIdentity"/> for the account specified</returns>\r
+            <remarks>\r
+            <para>\r
+            Uses the Windows API call LogonUser to get a principal token for the account. This\r
+            token is used to initialize the WindowsIdentity.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.WindowsSecurityContext.Credentials">\r
+            <summary>\r
+            Gets or sets the impersonation mode for this security context\r
+            </summary>\r
+            <value>\r
+            The impersonation mode for this security context\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            Impersonate either a user with user credentials or\r
+            revert this thread to the credentials of the process.\r
+            The value is one of the <see cref="T:log4net.Util.WindowsSecurityContext.ImpersonationMode"/>\r
+            enum.\r
+            </para>\r
+            <para>\r
+            The default value is <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>\r
+            </para>\r
+            <para>\r
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/>\r
+            the user's credentials are established using the\r
+            <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/>, <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.Password"/>\r
+            values.\r
+            </para>\r
+            <para>\r
+            When the mode is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process"/>\r
+            no other properties need to be set. If the calling thread is \r
+            impersonating then it will be reverted back to the process credentials.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.WindowsSecurityContext.UserName">\r
+            <summary>\r
+            Gets or sets the Windows username for this security context\r
+            </summary>\r
+            <value>\r
+            The Windows username for this security context\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>\r
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.WindowsSecurityContext.DomainName">\r
+            <summary>\r
+            Gets or sets the Windows domain name for this security context\r
+            </summary>\r
+            <value>\r
+            The Windows domain name for this security context\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The default value for <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> is the local machine name\r
+            taken from the <see cref="P:System.Environment.MachineName"/> property.\r
+            </para>\r
+            <para>\r
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>\r
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.Util.WindowsSecurityContext.Password">\r
+            <summary>\r
+            Sets the password for the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.\r
+            </summary>\r
+            <value>\r
+            The password for the Windows account specified by the <see cref="P:log4net.Util.WindowsSecurityContext.UserName"/> and <see cref="P:log4net.Util.WindowsSecurityContext.DomainName"/> properties.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            This property must be set if <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/>\r
+            is set to <see cref="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User"/> (the default setting).\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.Util.WindowsSecurityContext.ImpersonationMode">\r
+            <summary>\r
+            The impersonation modes for the <see cref="T:log4net.Util.WindowsSecurityContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            See the <see cref="P:log4net.Util.WindowsSecurityContext.Credentials"/> property for\r
+            details.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.User">\r
+            <summary>\r
+            Impersonate a user using the credentials supplied\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.Util.WindowsSecurityContext.ImpersonationMode.Process">\r
+            <summary>\r
+            Revert this the thread to the credentials of the process\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext">\r
+            <summary>\r
+            Adds <see cref="T:System.IDisposable"/> to <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Helper class to expose the <see cref="T:System.Security.Principal.WindowsImpersonationContext"/>\r
+            through the <see cref="T:System.IDisposable"/> interface.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.#ctor(System.Security.Principal.WindowsImpersonationContext)">\r
+            <summary>\r
+            Constructor\r
+            </summary>\r
+            <param name="impersonationContext">the impersonation context being wrapped</param>\r
+            <remarks>\r
+            <para>\r
+            Constructor\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.Util.WindowsSecurityContext.DisposableImpersonationContext.Dispose">\r
+            <summary>\r
+            Revert the impersonation\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Revert the impersonation\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.GlobalContext">\r
+            <summary>\r
+            The log4net Global Context.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>GlobalContext</c> provides a location for global debugging \r
+            information to be stored.\r
+            </para>\r
+            <para>\r
+            The global context has a properties map and these properties can \r
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>\r
+            supports selecting and outputing these properties.\r
+            </para>\r
+            <para>\r
+            By default the <c>log4net:HostName</c> property is set to the name of \r
+            the current machine.\r
+            </para>\r
+            </remarks>\r
+            <example>\r
+            <code lang="C#">\r
+            GlobalContext.Properties["hostname"] = Environment.MachineName;\r
+            </code>\r
+            </example>\r
+            <threadsafety static="true" instance="true"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.GlobalContext.#ctor">\r
+            <summary>\r
+            Private Constructor. \r
+            </summary>\r
+            <remarks>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.GlobalContext.s_properties">\r
+            <summary>\r
+            The global context properties instance\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.GlobalContext.Properties">\r
+            <summary>\r
+            The global properties map.\r
+            </summary>\r
+            <value>\r
+            The global properties map.\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The global properties map.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.AssemblyInfo">\r
+            <summary>\r
+            Provides information about the environment the assembly has\r
+            been built for.\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.AssemblyInfo.Version">\r
+            <summary>Version of the assembly</summary>\r
+        </member>\r
+        <member name="F:log4net.AssemblyInfo.TargetFrameworkVersion">\r
+            <summary>Version of the framework targeted</summary>\r
+        </member>\r
+        <member name="F:log4net.AssemblyInfo.TargetFramework">\r
+            <summary>Type of framework targeted</summary>\r
+        </member>\r
+        <member name="F:log4net.AssemblyInfo.ClientProfile">\r
+            <summary>Does it target a client profile?</summary>\r
+        </member>\r
+        <member name="P:log4net.AssemblyInfo.Info">\r
+            <summary>\r
+            Identifies the version and target for this assembly.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.LogicalThreadContext">\r
+            <summary>\r
+            The log4net Logical Thread Context.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>LogicalThreadContext</c> provides a location for <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> specific debugging \r
+            information to be stored.\r
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> or <see cref="T:log4net.GlobalContext"/>\r
+            properties with the same name.\r
+            </para>\r
+            <para>\r
+            The Logical Thread Context has a properties map and a stack.\r
+            The properties and stack can \r
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>\r
+            supports selecting and outputting these properties.\r
+            </para>\r
+            <para>\r
+            The Logical Thread Context provides a diagnostic context for the current call context. \r
+            This is an instrument for distinguishing interleaved log\r
+            output from different sources. Log output is typically interleaved\r
+            when a server handles multiple clients near-simultaneously.\r
+            </para>\r
+            <para>\r
+            The Logical Thread Context is managed on a per <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> basis.\r
+            </para>\r
+            <para>\r
+            The <see cref="T:System.Runtime.Remoting.Messaging.CallContext"/> requires a link time \r
+            <see cref="T:System.Security.Permissions.SecurityPermission"/> for the\r
+            <see cref="F:System.Security.Permissions.SecurityPermissionFlag.Infrastructure"/>.\r
+            If the calling code does not have this permission then this context will be disabled.\r
+            It will not store any property values set on it.\r
+            </para>\r
+            </remarks>\r
+            <example>Example of using the thread context properties to store a username.\r
+            <code lang="C#">\r
+            LogicalThreadContext.Properties["user"] = userName;\r
+            log.Info("This log message has a LogicalThreadContext Property called 'user'");\r
+            </code>\r
+            </example>\r
+            <example>Example of how to push a message into the context stack\r
+            <code lang="C#">\r
+            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))\r
+            {\r
+               log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");\r
+            \r
+            } // at the end of the using block the message is automatically popped \r
+            </code>\r
+            </example>\r
+            <threadsafety static="true" instance="true"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.LogicalThreadContext.#ctor">\r
+            <summary>\r
+            Private Constructor. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.LogicalThreadContext.s_properties">\r
+            <summary>\r
+            The thread context properties instance\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.LogicalThreadContext.s_stacks">\r
+            <summary>\r
+            The thread context stacks instance\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.LogicalThreadContext.Properties">\r
+            <summary>\r
+            The thread properties map\r
+            </summary>\r
+            <value>\r
+            The thread properties map\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <c>LogicalThreadContext</c> properties override any <see cref="T:log4net.ThreadContext"/> \r
+            or <see cref="T:log4net.GlobalContext"/> properties with the same name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.LogicalThreadContext.Stacks">\r
+            <summary>\r
+            The thread stacks\r
+            </summary>\r
+            <value>\r
+            stack map\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The logical thread stacks.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.LogManager">\r
+            <summary>\r
+            This class is used by client applications to request logger instances.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            This class has static methods that are used by a client to request\r
+            a logger instance. The <see cref="M:GetLogger(string)"/> method is \r
+            used to retrieve a logger.\r
+            </para>\r
+            <para>\r
+            See the <see cref="T:log4net.ILog"/> interface for more details.\r
+            </para>\r
+            </remarks>\r
+            <example>Simple example of logging messages\r
+            <code lang="C#">\r
+            ILog log = LogManager.GetLogger("application-log");\r
+            \r
+            log.Info("Application Start");\r
+            log.Debug("This is a debug message");\r
+            \r
+            if (log.IsDebugEnabled)\r
+            {\r
+               log.Debug("This is another debug message");\r
+            }\r
+            </code>\r
+            </example>\r
+            <threadsafety static="true" instance="true"/>\r
+            <seealso cref="T:log4net.ILog"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.LogManager.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.LogManager"/> class. \r
+            </summary>\r
+            <remarks>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.LogManager.Exists(System.String)">\r
+            <overloads>Returns the named logger if it exists.</overloads>\r
+            <summary>\r
+            Returns the named logger if it exists.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If the named logger exists (in the default repository) then it\r
+            returns a reference to the logger, otherwise it returns <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+            <param name="name">The fully qualified logger name to look for.</param>\r
+            <returns>The logger found, or <c>null</c> if no logger could be found.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.Exists(System.String,System.String)">\r
+            <summary>\r
+            Returns the named logger if it exists.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If the named logger exists (in the specified repository) then it\r
+            returns a reference to the logger, otherwise it returns\r
+            <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <param name="name">The fully qualified logger name to look for.</param>\r
+            <returns>\r
+            The logger found, or <c>null</c> if the logger doesn't exist in the specified \r
+            repository.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.Exists(System.Reflection.Assembly,System.String)">\r
+            <summary>\r
+            Returns the named logger if it exists.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            If the named logger exists (in the repository for the specified assembly) then it\r
+            returns a reference to the logger, otherwise it returns\r
+            <c>null</c>.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <param name="name">The fully qualified logger name to look for.</param>\r
+            <returns>\r
+            The logger, or <c>null</c> if the logger doesn't exist in the specified\r
+            assembly's repository.\r
+            </returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetCurrentLoggers">\r
+            <overloads>Get the currently defined loggers.</overloads>\r
+            <summary>\r
+            Returns all the currently defined loggers in the default repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>The root logger is <b>not</b> included in the returned array.</para>\r
+            </remarks>\r
+            <returns>All the defined loggers.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.String)">\r
+            <summary>\r
+            Returns all the currently defined loggers in the specified repository.\r
+            </summary>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <remarks>\r
+            The root logger is <b>not</b> included in the returned array.\r
+            </remarks>\r
+            <returns>All the defined loggers.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetCurrentLoggers(System.Reflection.Assembly)">\r
+            <summary>\r
+            Returns all the currently defined loggers in the specified assembly's repository.\r
+            </summary>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <remarks>\r
+            The root logger is <b>not</b> included in the returned array.\r
+            </remarks>\r
+            <returns>All the defined loggers.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLogger(System.String)">\r
+            <overloads>Get or create a logger.</overloads>\r
+            <summary>\r
+            Retrieves or creates a named logger.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Retrieves a logger named as the <paramref name="name"/>\r
+            parameter. If the named logger already exists, then the\r
+            existing instance will be returned. Otherwise, a new instance is\r
+            created.\r
+            </para>\r
+            <para>By default, loggers do not have a set level but inherit\r
+            it from the hierarchy. This is one of the central features of\r
+            log4net.\r
+            </para>\r
+            </remarks>\r
+            <param name="name">The name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.String)">\r
+            <summary>\r
+            Retrieves or creates a named logger.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Retrieve a logger named as the <paramref name="name"/>\r
+            parameter. If the named logger already exists, then the\r
+            existing instance will be returned. Otherwise, a new instance is\r
+            created.\r
+            </para>\r
+            <para>\r
+            By default, loggers do not have a set level but inherit\r
+            it from the hierarchy. This is one of the central features of\r
+            log4net.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <param name="name">The name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.String)">\r
+            <summary>\r
+            Retrieves or creates a named logger.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Retrieve a logger named as the <paramref name="name"/>\r
+            parameter. If the named logger already exists, then the\r
+            existing instance will be returned. Otherwise, a new instance is\r
+            created.\r
+            </para>\r
+            <para>\r
+            By default, loggers do not have a set level but inherit\r
+            it from the hierarchy. This is one of the central features of\r
+            log4net.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <param name="name">The name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLogger(System.Type)">\r
+            <summary>\r
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.\r
+            </summary>\r
+            <remarks>\r
+            Get the logger for the fully qualified name of the type specified.\r
+            </remarks>\r
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLogger(System.String,System.Type)">\r
+            <summary>\r
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.\r
+            </summary>\r
+            <remarks>\r
+            Gets the logger for the fully qualified name of the type specified.\r
+            </remarks>\r
+            <param name="repository">The repository to lookup in.</param>\r
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLogger(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Shorthand for <see cref="M:LogManager.GetLogger(string)"/>.\r
+            </summary>\r
+            <remarks>\r
+            Gets the logger for the fully qualified name of the type specified.\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+            <param name="type">The full name of <paramref name="type"/> will be used as the name of the logger to retrieve.</param>\r
+            <returns>The logger with the name specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.Shutdown">\r
+            <summary>\r
+            Shuts down the log4net system.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in all the\r
+            default repositories.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.LogManager.ShutdownRepository">\r
+            <overloads>Shutdown a logger repository.</overloads>\r
+            <summary>\r
+            Shuts down the default repository.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in the\r
+            default repository.\r
+            </para>\r
+            <para>Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.LogManager.ShutdownRepository(System.String)">\r
+            <summary>\r
+            Shuts down the repository for the repository specified.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in the\r
+            <paramref name="repository"/> specified.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The repository to shutdown.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.ShutdownRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Shuts down the repository specified.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Calling this method will <b>safely</b> close and remove all\r
+            appenders in all the loggers including root contained in the\r
+            repository. The repository is looked up using\r
+            the <paramref name="repositoryAssembly"/> specified.\r
+            </para>\r
+            <para>\r
+            Some appenders need to be closed before the application exists. \r
+            Otherwise, pending logging events might be lost.\r
+            </para>\r
+            <para>\r
+            The <c>shutdown</c> method is careful to close nested\r
+            appenders before closing regular appenders. This is allows\r
+            configurations where a regular appender is attached to a logger\r
+            and again to a nested appender.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.ResetConfiguration">\r
+            <overloads>Reset the configuration of a repository</overloads>\r
+            <summary>\r
+            Resets all values contained in this repository instance to their defaults.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Resets all values contained in the repository instance to their\r
+            defaults.  This removes all appenders from all loggers, sets\r
+            the level of all non-root loggers to <c>null</c>,\r
+            sets their additivity flag to <c>true</c> and sets the level\r
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,\r
+            message disabling is set to its default "off" value.\r
+            </para>            \r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.LogManager.ResetConfiguration(System.String)">\r
+            <summary>\r
+            Resets all values contained in this repository instance to their defaults.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Reset all values contained in the repository instance to their\r
+            defaults.  This removes all appenders from all loggers, sets\r
+            the level of all non-root loggers to <c>null</c>,\r
+            sets their additivity flag to <c>true</c> and sets the level\r
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,\r
+            message disabling is set to its default "off" value.\r
+            </para>            \r
+            </remarks>\r
+            <param name="repository">The repository to reset.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.ResetConfiguration(System.Reflection.Assembly)">\r
+            <summary>\r
+            Resets all values contained in this repository instance to their defaults.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Reset all values contained in the repository instance to their\r
+            defaults.  This removes all appenders from all loggers, sets\r
+            the level of all non-root loggers to <c>null</c>,\r
+            sets their additivity flag to <c>true</c> and sets the level\r
+            of the root logger to <see cref="F:log4net.Core.Level.Debug"/>. Moreover,\r
+            message disabling is set to its default "off" value.\r
+            </para>            \r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository to reset.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLoggerRepository">\r
+            <overloads>Get the logger repository.</overloads>\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).\r
+            </para>\r
+            </remarks>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.String)">\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the <paramref name="repository"/> argument.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The repository to lookup in.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetLoggerRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the <paramref name="repositoryAssembly"/> argument.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetRepository">\r
+            <overloads>Get a logger repository.</overloads>\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the callers assembly (<see cref="M:Assembly.GetCallingAssembly()"/>).\r
+            </para>\r
+            </remarks>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> instance for the default repository.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetRepository(System.String)">\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the <paramref name="repository"/> argument.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The repository to lookup in.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetRepository(System.Reflection.Assembly)">\r
+            <summary>\r
+            Returns the default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.\r
+            </summary>\r
+            <returns>The default <see cref="T:log4net.Repository.ILoggerRepository"/> instance.</returns>\r
+            <remarks>\r
+            <para>\r
+            Gets the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified\r
+            by the <paramref name="repositoryAssembly"/> argument.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to lookup the repository.</param>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateDomain(System.Type)">\r
+            <overloads>Create a domain</overloads>\r
+            <summary>\r
+            Creates a repository with the specified repository type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository()"/> will return \r
+            the same repository instance.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateRepository(System.Type)">\r
+            <overloads>Create a logger repository.</overloads>\r
+            <summary>\r
+            Creates a repository with the specified repository type.\r
+            </summary>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository()"/> will return \r
+            the same repository instance.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateDomain(System.String)">\r
+            <summary>\r
+            Creates a repository with the specified name.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a\r
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.\r
+            </para>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateRepository(System.String)">\r
+            <summary>\r
+            Creates a repository with the specified name.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Creates the default type of <see cref="T:log4net.Repository.ILoggerRepository"/> which is a\r
+            <see cref="T:log4net.Repository.Hierarchy.Hierarchy"/> object.\r
+            </para>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The name of the repository, this must be unique amongst repositories.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateDomain(System.String,System.Type)">\r
+            <summary>\r
+            Creates a repository with the specified name and repository type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateRepository(System.String,System.Type)">\r
+            <summary>\r
+            Creates a repository with the specified name and repository type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <paramref name="repository"/> name must be unique. Repositories cannot be redefined.\r
+            An <see cref="T:System.Exception"/> will be thrown if the repository already exists.\r
+            </para>\r
+            </remarks>\r
+            <param name="repository">The name of the repository, this must be unique to the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+            <exception cref="T:log4net.Core.LogException">The specified repository already exists.</exception>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateDomain(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Creates a repository for the specified assembly and repository type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            <b>CreateDomain is obsolete. Use CreateRepository instead of CreateDomain.</b>\r
+            </para>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.CreateRepository(System.Reflection.Assembly,System.Type)">\r
+            <summary>\r
+            Creates a repository for the specified assembly and repository type.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <see cref="T:log4net.Repository.ILoggerRepository"/> created will be associated with the repository\r
+            specified such that a call to <see cref="M:GetRepository(Assembly)"/> with the\r
+            same assembly specified will return the same repository instance.\r
+            </para>\r
+            </remarks>\r
+            <param name="repositoryAssembly">The assembly to use to get the name of the repository.</param>\r
+            <param name="repositoryType">A <see cref="T:System.Type"/> that implements <see cref="T:log4net.Repository.ILoggerRepository"/>\r
+            and has a no arg constructor. An instance of this type will be created to act\r
+            as the <see cref="T:log4net.Repository.ILoggerRepository"/> for the repository specified.</param>\r
+            <returns>The <see cref="T:log4net.Repository.ILoggerRepository"/> created for the repository.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.GetAllRepositories">\r
+            <summary>\r
+            Gets the list of currently defined repositories.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Get an array of all the <see cref="T:log4net.Repository.ILoggerRepository"/> objects that have been created.\r
+            </para>\r
+            </remarks>\r
+            <returns>An array of all the known <see cref="T:log4net.Repository.ILoggerRepository"/> objects.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.WrapLogger(log4net.Core.ILogger)">\r
+            <summary>\r
+            Looks up the wrapper object for the logger specified.\r
+            </summary>\r
+            <param name="logger">The logger to get the wrapper for.</param>\r
+            <returns>The wrapper for the logger specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.WrapLoggers(log4net.Core.ILogger[])">\r
+            <summary>\r
+            Looks up the wrapper objects for the loggers specified.\r
+            </summary>\r
+            <param name="loggers">The loggers to get the wrappers for.</param>\r
+            <returns>The wrapper objects for the loggers specified.</returns>\r
+        </member>\r
+        <member name="M:log4net.LogManager.WrapperCreationHandler(log4net.Core.ILogger)">\r
+            <summary>\r
+            Create the <see cref="T:log4net.Core.ILoggerWrapper"/> objects used by\r
+            this manager.\r
+            </summary>\r
+            <param name="logger">The logger to wrap.</param>\r
+            <returns>The wrapper for the logger specified.</returns>\r
+        </member>\r
+        <member name="F:log4net.LogManager.s_wrapperMap">\r
+            <summary>\r
+            The wrapper map to use to hold the <see cref="T:log4net.Core.LogImpl"/> objects.\r
+            </summary>\r
+        </member>\r
+        <member name="T:log4net.MDC">\r
+            <summary>\r
+            Implementation of Mapped Diagnostic Contexts.\r
+            </summary>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.\r
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            The MDC class is similar to the <see cref="T:log4net.NDC"/> class except that it is\r
+            based on a map instead of a stack. It provides <i>mapped\r
+            diagnostic contexts</i>. A <i>Mapped Diagnostic Context</i>, or\r
+            MDC in short, is an instrument for distinguishing interleaved log\r
+            output from different sources. Log output is typically interleaved\r
+            when a server handles multiple clients near-simultaneously.\r
+            </para>\r
+            <para>\r
+            The MDC is managed on a per thread basis.\r
+            </para>\r
+            </remarks>\r
+            <threadsafety static="true" instance="true"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.MDC.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.MDC"/> class. \r
+            </summary>\r
+            <remarks>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.MDC.Get(System.String)">\r
+            <summary>\r
+            Gets the context value identified by the <paramref name="key"/> parameter.\r
+            </summary>\r
+            <param name="key">The key to lookup in the MDC.</param>\r
+            <returns>The string value held for the key, or a <c>null</c> reference if no corresponding value is found.</returns>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.\r
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            If the <paramref name="key"/> parameter does not look up to a\r
+            previously defined context then <c>null</c> will be returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.MDC.Set(System.String,System.String)">\r
+            <summary>\r
+            Add an entry to the MDC\r
+            </summary>\r
+            <param name="key">The key to store the value under.</param>\r
+            <param name="value">The value to store.</param>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.\r
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Puts a context value (the <paramref name="value"/> parameter) as identified\r
+            with the <paramref name="key"/> parameter into the current thread's\r
+            context map.\r
+            </para>\r
+            <para>\r
+            If a value is already defined for the <paramref name="key"/>\r
+            specified then the value will be replaced. If the <paramref name="value"/> \r
+            is specified as <c>null</c> then the key value mapping will be removed.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.MDC.Remove(System.String)">\r
+            <summary>\r
+            Removes the key value mapping for the key specified.\r
+            </summary>\r
+            <param name="key">The key to remove.</param>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.\r
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Remove the specified entry from this thread's MDC\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.MDC.Clear">\r
+            <summary>\r
+            Clear all entries in the MDC\r
+            </summary>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The MDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Properties"/>.\r
+            The current MDC implementation forwards to the <c>ThreadContext.Properties</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Remove all the entries from this thread's MDC\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="T:log4net.NDC">\r
+            <summary>\r
+            Implementation of Nested Diagnostic Contexts.\r
+            </summary>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            A Nested Diagnostic Context, or NDC in short, is an instrument\r
+            to distinguish interleaved log output from different sources. Log\r
+            output is typically interleaved when a server handles multiple\r
+            clients near-simultaneously.\r
+            </para>\r
+            <para>\r
+            Interleaved log output can still be meaningful if each log entry\r
+            from different contexts had a distinctive stamp. This is where NDCs\r
+            come into play.\r
+            </para>\r
+            <para>\r
+            Note that NDCs are managed on a per thread basis. The NDC class\r
+            is made up of static methods that operate on the context of the\r
+            calling thread.\r
+            </para>\r
+            </remarks>\r
+            <example>How to push a message into the context\r
+            <code lang="C#">\r
+            using(NDC.Push("my context message"))\r
+            {\r
+               ... all log calls will have 'my context message' included ...\r
+            \r
+            } // at the end of the using block the message is automatically removed \r
+            </code>\r
+            </example>\r
+            <threadsafety static="true" instance="true"/>\r
+            <author>Nicko Cadell</author>\r
+            <author>Gert Driesen</author>\r
+        </member>\r
+        <member name="M:log4net.NDC.#ctor">\r
+            <summary>\r
+            Initializes a new instance of the <see cref="T:log4net.NDC"/> class. \r
+            </summary>\r
+            <remarks>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.NDC.Clear">\r
+            <summary>\r
+            Clears all the contextual information held on the current thread.\r
+            </summary>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Clears the stack of NDC data held on the current thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.NDC.CloneStack">\r
+            <summary>\r
+            Creates a clone of the stack of context information.\r
+            </summary>\r
+            <returns>A clone of the context info for this thread.</returns>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            The results of this method can be passed to the <see cref="M:log4net.NDC.Inherit(System.Collections.Stack)"/> \r
+            method to allow child threads to inherit the context of their \r
+            parent thread.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.NDC.Inherit(System.Collections.Stack)">\r
+            <summary>\r
+            Inherits the contextual information from another thread.\r
+            </summary>\r
+            <param name="stack">The context stack to inherit.</param>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            This thread will use the context information from the stack\r
+            supplied. This can be used to initialize child threads with\r
+            the same contextual information as their parent threads. These\r
+            contexts will <b>NOT</b> be shared. Any further contexts that\r
+            are pushed onto the stack will not be visible to the other.\r
+            Call <see cref="M:log4net.NDC.CloneStack"/> to obtain a stack to pass to\r
+            this method.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.NDC.Pop">\r
+            <summary>\r
+            Removes the top context from the stack.\r
+            </summary>\r
+            <returns>\r
+            The message in the context that was removed from the top \r
+            of the stack.\r
+            </returns>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Remove the top context from the stack, and return\r
+            it to the caller. If the stack is empty then an\r
+            empty string (not <c>null</c>) is returned.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.NDC.Push(System.String)">\r
+            <summary>\r
+            Pushes a new context message.\r
+            </summary>\r
+            <param name="message">The new context message.</param>\r
+            <returns>\r
+            An <see cref="T:System.IDisposable"/> that can be used to clean up \r
+            the context stack.\r
+            </returns>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Pushes a new context onto the context stack. An <see cref="T:System.IDisposable"/>\r
+            is returned that can be used to clean up the context stack. This\r
+            can be easily combined with the <c>using</c> keyword to scope the\r
+            context.\r
+            </para>\r
+            </remarks>\r
+            <example>Simple example of using the <c>Push</c> method with the <c>using</c> keyword.\r
+            <code lang="C#">\r
+            using(log4net.NDC.Push("NDC_Message"))\r
+            {\r
+               log.Warn("This should have an NDC message");\r
+            }\r
+            </code>\r
+            </example>\r
+        </member>\r
+        <member name="M:log4net.NDC.Remove">\r
+            <summary>\r
+            Removes the context information for this thread. It is\r
+            not required to call this method.\r
+            </summary>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            This method is not implemented.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="M:log4net.NDC.SetMaxDepth(System.Int32)">\r
+            <summary>\r
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.\r
+            </summary>\r
+            <param name="maxDepth">The maximum depth of the stack</param>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            Forces the stack depth to be at most <paramref name="maxDepth"/>.\r
+            This may truncate the head of the stack. This only affects the \r
+            stack in the current thread. Also it does not prevent it from\r
+            growing, it only sets the maximum depth at the time of the\r
+            call. This can be used to return to a known context depth.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.NDC.Depth">\r
+            <summary>\r
+            Gets the current context depth.\r
+            </summary>\r
+            <value>The current context depth.</value>\r
+            <remarks>\r
+            <note>\r
+            <para>\r
+            The NDC is deprecated and has been replaced by the <see cref="P:log4net.ThreadContext.Stacks"/>.\r
+            The current NDC implementation forwards to the <c>ThreadContext.Stacks["NDC"]</c>.\r
+            </para>\r
+            </note>\r
+            <para>\r
+            The number of context values pushed onto the context stack.\r
+            </para>\r
+            <para>\r
+            Used to record the current depth of the context. This can then \r
+            be restored using the <see cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/> method.\r
+            </para>\r
+            </remarks>\r
+            <seealso cref="M:log4net.NDC.SetMaxDepth(System.Int32)"/>\r
+        </member>\r
+        <member name="T:log4net.ThreadContext">\r
+            <summary>\r
+            The log4net Thread Context.\r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            The <c>ThreadContext</c> provides a location for thread specific debugging \r
+            information to be stored.\r
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>\r
+            properties with the same name.\r
+            </para>\r
+            <para>\r
+            The thread context has a properties map and a stack.\r
+            The properties and stack can \r
+            be included in the output of log messages. The <see cref="T:log4net.Layout.PatternLayout"/>\r
+            supports selecting and outputting these properties.\r
+            </para>\r
+            <para>\r
+            The Thread Context provides a diagnostic context for the current thread. \r
+            This is an instrument for distinguishing interleaved log\r
+            output from different sources. Log output is typically interleaved\r
+            when a server handles multiple clients near-simultaneously.\r
+            </para>\r
+            <para>\r
+            The Thread Context is managed on a per thread basis.\r
+            </para>\r
+            </remarks>\r
+            <example>Example of using the thread context properties to store a username.\r
+            <code lang="C#">\r
+            ThreadContext.Properties["user"] = userName;\r
+            log.Info("This log message has a ThreadContext Property called 'user'");\r
+            </code>\r
+            </example>\r
+            <example>Example of how to push a message into the context stack\r
+            <code lang="C#">\r
+            using(ThreadContext.Stacks["NDC"].Push("my context message"))\r
+            {\r
+               log.Info("This log message has a ThreadContext Stack message that includes 'my context message'");\r
+            \r
+            } // at the end of the using block the message is automatically popped \r
+            </code>\r
+            </example>\r
+            <threadsafety static="true" instance="true"/>\r
+            <author>Nicko Cadell</author>\r
+        </member>\r
+        <member name="M:log4net.ThreadContext.#ctor">\r
+            <summary>\r
+            Private Constructor. \r
+            </summary>\r
+            <remarks>\r
+            <para>\r
+            Uses a private access modifier to prevent instantiation of this class.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="F:log4net.ThreadContext.s_properties">\r
+            <summary>\r
+            The thread context properties instance\r
+            </summary>\r
+        </member>\r
+        <member name="F:log4net.ThreadContext.s_stacks">\r
+            <summary>\r
+            The thread context stacks instance\r
+            </summary>\r
+        </member>\r
+        <member name="P:log4net.ThreadContext.Properties">\r
+            <summary>\r
+            The thread properties map\r
+            </summary>\r
+            <value>\r
+            The thread properties map\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The <c>ThreadContext</c> properties override any <see cref="T:log4net.GlobalContext"/>\r
+            properties with the same name.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+        <member name="P:log4net.ThreadContext.Stacks">\r
+            <summary>\r
+            The thread stacks\r
+            </summary>\r
+            <value>\r
+            stack map\r
+            </value>\r
+            <remarks>\r
+            <para>\r
+            The thread local stacks.\r
+            </para>\r
+            </remarks>\r
+        </member>\r
+    </members>\r
+</doc>\r

diff --git a/TrotiNet/Log.cs b/TrotiNet/Log.cs
index 34e16fe..b940716 100644 (file)
--- a/TrotiNet/Log.cs
+++ b/TrotiNet/Log.cs
@@ -21,11 +21,12 @@ namespace TrotiNet
 #endif\r
         }\r
     }\r
-\r
+#if !LOG4NET\r
     internal class ILog\r
     {\r
         public void Info(string s) {}\r
         public void Debug(string s) {}\r
         public void Error(Exception e) {}\r
     }\r
+#endif\r
 }\r

diff --git a/TrotiNet/Properties/AssemblyInfo.cs b/TrotiNet/Properties/AssemblyInfo.cs
index 5a5e95d..ca0bca4 100644 (file)
--- a/TrotiNet/Properties/AssemblyInfo.cs
+++ b/TrotiNet/Properties/AssemblyInfo.cs
@@ -33,3 +33,5 @@ using System.Runtime.InteropServices;
 // by using the '*' as shown below:\r
 // [assembly: AssemblyVersion("1.0.*")]\r
 [assembly: AssemblyVersion("0.8.0")]\r
+\r
+[assembly: log4net.Config.XmlConfigurator(Watch = true)]\r

diff --git a/TrotiNet/ProxyLogic.cs b/TrotiNet/ProxyLogic.cs
index 1db58a2..e84a0d7 100644 (file)
--- a/TrotiNet/ProxyLogic.cs
+++ b/TrotiNet/ProxyLogic.cs
@@ -8,6 +8,9 @@
     using System.Net.Sockets;\r
     using System.Text;\r
     using System.Threading;\r
+#if LOG4NET\r
+    using log4net;\r
+#endif\r
 \r
     /// <summary>\r
     /// Abstract class for all HTTP proxy logic implementations\r
@@ -270,7 +273,7 @@
                 {\r
                     hrl.URI = hrl.URI.Substring(prefix);\r
                     log.Debug("Rewriting request line as: " +\r
-                        hrl.RequestLine);\r
+                        RemoveApiToken(hrl.RequestLine));\r
                 }\r
 \r
                 return host;\r
@@ -339,6 +342,15 @@
             if (SocketPS.WriteBinary(msg, position, to_send) < to_send)\r
                 throw new IoBroken();\r
         }\r
+\r
+        /// <summary>\r
+        /// Remove api_token from URI\r
+        /// </summary>\r
+        protected string RemoveApiToken(string str)\r
+        {\r
+            var idx = str.IndexOf("api_token", StringComparison.Ordinal);\r
+            return idx == -1 ? str : str.Substring(0, idx);\r
+        }\r
     }\r
 \r
     /// <summary>\r
@@ -549,7 +561,7 @@
 \r
             RequestHeaders = new HttpHeaders(SocketBP);\r
 \r
-            log.Info("Got request " + RequestLine.RequestLine);\r
+            log.Info("Got request " + RemoveApiToken(RequestLine.RequestLine));\r
 \r
             // We call OnReceiveRequest now because Connect() will\r
             // modify the request URI.\r

diff --git a/TrotiNet/TcpServer.cs b/TrotiNet/TcpServer.cs
index d8a9e4a..ecbce3b 100644 (file)
--- a/TrotiNet/TcpServer.cs
+++ b/TrotiNet/TcpServer.cs
@@ -19,6 +19,9 @@ using System.Net;
 using System.Net.Sockets;\r
 using System.Runtime.CompilerServices;\r
 using System.Threading;\r
+#if LOG4NET\r
+using log4net;\r
+#endif\r
 \r
 [assembly: InternalsVisibleTo("TrotiNet.Test")]\r
 namespace TrotiNet\r

diff --git a/TrotiNet/TrotiNet.Lib.csproj b/TrotiNet/TrotiNet.Lib.csproj
index c00745f..d6b33e4 100644 (file)
--- a/TrotiNet/TrotiNet.Lib.csproj
+++ b/TrotiNet/TrotiNet.Lib.csproj
@@ -41,7 +41,7 @@
     <DebugType>full</DebugType>\r
     <Optimize>false</Optimize>\r
     <OutputPath>bin\Debug\</OutputPath>\r
-    <DefineConstants>DEBUG;TRACE</DefineConstants>\r
+    <DefineConstants>TRACE;DEBUG;LOG4NET</DefineConstants>\r
     <ErrorReport>prompt</ErrorReport>\r
     <WarningLevel>4</WarningLevel>\r
     <DocumentationFile>bin\Debug\TrotiNet.xml</DocumentationFile>\r
@@ -78,6 +78,9 @@
     <Prefer32Bit>false</Prefer32Bit>\r
   </PropertyGroup>\r
   <ItemGroup>\r
+    <Reference Include="log4net">\r
+      <HintPath>..\Libraries\log4net\log4net.dll</HintPath>\r
+    </Reference>\r
     <Reference Include="System" />\r
     <Reference Include="System.XML" />\r
   </ItemGroup>\r